From 749dc67a08db1161cb3d82d26301b3cb4f86aaf9 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 12 Apr 2026 01:25:07 -0700 Subject: [PATCH 01/10] feat: add PTBXLDataset and PTBXLMultilabelClassification task - pyhealth/datasets/ptbxl.py: BaseSignalDataset subclass for PTB-XL v1.0.3 - pyhealth/tasks/ptbxl_multilabel_classification.py: 5-class superdiagnostic task - examples/ptbxl_superdiagnostic_sparcnet.ipynb: ablation study (SparcNet vs BiLSTM) - tests/core/test_ptbxl.py: unit tests - cs598_project/: CS-598 course project pipeline notebook Results: SparcNet ROC-AUC 0.9278, BiLSTMECG ROC-AUC 0.9155 on PTB-XL test set --- .gitignore | 11 +- cs598_project/PTBXLImplementation.md | 968 ++++ cs598_project/ptbxl_pyhealth_pipeline.ipynb | 4645 +++++++++++++++++ docs/api/tasks.rst | 1 + ...th.tasks.PTBXLMultilabelClassification.rst | 18 + examples/ptbxl_superdiagnostic_sparcnet.ipynb | 547 ++ pyhealth/datasets/__init__.py | 1 + pyhealth/datasets/configs/ptbxl.yaml | 13 + pyhealth/tasks/__init__.py | 1 + .../tasks/ptbxl_multilabel_classification.py | 728 +-- tests/core/test_ptbxl.py | 454 ++ 11 files changed, 7022 insertions(+), 365 deletions(-) create mode 100644 cs598_project/PTBXLImplementation.md create mode 100644 cs598_project/ptbxl_pyhealth_pipeline.ipynb create mode 100644 docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst create mode 100644 examples/ptbxl_superdiagnostic_sparcnet.ipynb create mode 100644 pyhealth/datasets/configs/ptbxl.yaml create mode 100644 tests/core/test_ptbxl.py diff --git a/.gitignore b/.gitignore index 9993737db..9a9bb7abf 100644 --- a/.gitignore +++ b/.gitignore @@ -139,4 +139,13 @@ data/physionet.org/ .vscode/ # Model weight files (large binaries, distributed separately) -weightfiles/ \ No newline at end of file +weightfiles/ +# CS-598 project data (downloaded separately — not library code) +cs598_project/ptbxl_database.csv +cs598_project/scp_statements.csv +cs598_project/ptbxl-records-pyhealth.csv +cs598_project/ptbxl_v103_pyhealth.yaml +cs598_project/WFDB +cs598_project/output/ +cs598_project/**/*.pkl +cs598_project/**/*.ckpt diff --git a/cs598_project/PTBXLImplementation.md b/cs598_project/PTBXLImplementation.md new file mode 100644 index 000000000..6b0588162 --- /dev/null +++ b/cs598_project/PTBXLImplementation.md @@ -0,0 +1,968 @@ +# PTB-XL ECG Classification — Complete Implementation Guide + +**Course:** CS-598 Deep Learning for Healthcare +**Project:** PTB-XL Dataset + Multi-Label Task integration into PyHealth 2.0 +**Stack:** Python ≥ 3.12 · PyTorch 2.7 · PyHealth 2.0 + +--- + +## Table of Contents + +1. [Project Overview](#1-project-overview) +2. [Repository File Map](#2-repository-file-map) +3. [PyHealth 5-Stage Pipeline](#3-pyhealth-5-stage-pipeline) +4. [Stage 1 — Dataset Implementation](#4-stage-1--dataset-implementation) + - 4.1 [YAML Config](#41-yaml-config-pyhealth.datasets.configs.ptbxl.yaml) + - 4.2 [PTBXLDataset Class](#42-ptbxldataset-class) + - 4.3 [prepare_metadata Flow](#43-preparemetadata-flow) + - 4.4 [Header Parsing](#44-header-parsing) + - 4.5 [Dataset → BaseDataset Sequence](#45-dataset--basedataset-sequence) +5. [Stage 2 — Task Implementation](#5-stage-2--task-implementation) + - 5.1 [Label Space Definitions](#51-label-space-definitions) + - 5.2 [PTBXLMultilabelClassification Class](#52-ptbxlmultilabelclassification-class) + - 5.3 [\_\_call\_\_ Flow per Patient](#53-__call__-flow-per-patient) + - 5.4 [Decimation: 500 Hz → 100 Hz](#54-decimation-500-hz--100-hz) +6. [Mathematical Framing](#6-mathematical-framing) + - 6.1 [Signal Representation](#61-signal-representation) + - 6.2 [Forward Pass](#62-forward-pass) + - 6.3 [Loss Function](#63-loss-function) + - 6.4 [Evaluation Metrics](#64-evaluation-metrics) +7. [Ablation Study Design](#7-ablation-study-design) +8. [Module Registration (\_\_init\_\_ imports)](#8-module-registration-__init__-imports) +9. [Documentation (RST + toctree)](#9-documentation-rst--toctree) +10. [Test Suite](#10-test-suite) + - 10.1 [Test Architecture](#101-test-architecture) + - 10.2 [Dataset Tests](#102-dataset-tests) + - 10.3 [Task Tests](#103-task-tests) +11. [Example Notebook — Ablation Study](#11-example-notebook--ablation-study) + - 11.1 [End-to-End Pipeline Sequence](#111-end-to-end-pipeline-sequence) +12. [Data Layout](#12-data-layout) +13. [Dependency Graph](#13-dependency-graph) +14. [References](#14-references) + +--- + +## 1. Project Overview + +PTB-XL is the largest openly available clinical 12-lead ECG dataset (21,837 recordings, 18,885 patients, Charité Hospital Berlin). This project integrates it fully into the **PyHealth 2.0** framework by implementing: + +| Deliverable | File | Purpose | +|---|---|---| +| Dataset class | `pyhealth/datasets/ptbxl.py` | Parse raw WFDB files into PyHealth patient records | +| YAML schema | `pyhealth/datasets/configs/ptbxl.yaml` | Tell BaseDataset which columns to load | +| Task class | `pyhealth/tasks/ptbxl_multilabel_classification.py` | Convert patient records to ML samples | +| Dataset RST | `docs/api/datasets/pyhealth.datasets.PTBXLDataset.rst` | Sphinx API doc for dataset | +| Task RST | `docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst` | Sphinx API doc for task | +| datasets.rst entry | `docs/api/datasets.rst` (line 241) | toctree link to dataset doc | +| tasks.rst entry | `docs/api/tasks.rst` (line 232) | toctree link to task doc | +| Test file | `tests/core/test_ptbxl.py` | 18 offline unit tests | +| Example notebook | `examples/ptbxl_superdiagnostic_sparcnet.ipynb` | Ablation study | + +--- + +## 2. Repository File Map + +``` +PyHealth/ +├── pyhealth/ +│ ├── datasets/ +│ │ ├── __init__.py ← imports PTBXLDataset +│ │ ├── ptbxl.py ← ★ Dataset implementation +│ │ ├── base_dataset.py ← Parent class (LitData + Polars backend) +│ │ └── configs/ +│ │ └── ptbxl.yaml ← ★ YAML schema +│ ├── tasks/ +│ │ ├── __init__.py ← imports PTBXLMultilabelClassification +│ │ ├── ptbxl_multilabel_classification.py ← ★ Task implementation +│ │ └── base_task.py ← Parent class +│ └── models/ +│ └── sparcnet.py ← Model used in ablation +├── docs/api/ +│ ├── datasets.rst ← ★ toctree entry added +│ ├── tasks.rst ← ★ toctree entry added +│ ├── datasets/ +│ │ └── pyhealth.datasets.PTBXLDataset.rst ← ★ Dataset doc +│ └── tasks/ +│ └── pyhealth.tasks.PTBXLMultilabelClassification.rst ← ★ Task doc +├── tests/core/ +│ └── test_ptbxl.py ← ★ Unit tests (18 cases) +└── examples/ + └── ptbxl_superdiagnostic_sparcnet.ipynb ← ★ Ablation notebook +``` + +--- + +## 3. PyHealth 5-Stage Pipeline + +Every PyHealth 2.0 project follows a strictly ordered 5-stage pipeline. The boxes in **bold** are where our code lives. + +```mermaid +flowchart LR + A["Stage 1\nDataset Process\npyhealth.datasets"] --> + B["Stage 2\nDefine Task\npyhealth.tasks"] --> + C["Stage 3\nModel Init\npyhealth.models"] --> + D["Stage 4\nTraining\npyhealth.trainer"] --> + E["Stage 5\nInference & Eval\npyhealth.metrics"] + + style A fill:#4a90d9,color:#fff + style B fill:#27ae60,color:#fff + style C fill:#8e44ad,color:#fff + style D fill:#e67e22,color:#fff + style E fill:#c0392b,color:#fff +``` + +| Stage | API | Our contribution | +|---|---|---| +| 1 Dataset Process | `pyhealth.datasets.PTBXLDataset` | Parses WFDB `.hea`/`.mat` files | +| 2 Define Task | `pyhealth.tasks.PTBXLMultilabelClassification` | 2×2 ablation (label_type × rate) | +| 3 Model Init | `pyhealth.models.SparcNet` | Existing model, no change needed | +| 4 Training | `pyhealth.trainer.Trainer` | Existing trainer, no change needed | +| 5 Eval | `pyhealth.metrics.multilabel_metrics_fn` | macro ROC-AUC + macro F1 | + +--- + +## 4. Stage 1 — Dataset Implementation + +### 4.1 YAML Config (`pyhealth/datasets/configs/ptbxl.yaml`) + +The YAML file tells `BaseDataset` how to interpret the metadata CSV we generate: + +```yaml +version: "1.0.0" + +tables: + ptbxl: + file_path: "ptbxl-pyhealth.csv" # CSV produced by prepare_metadata() + patient_id: "patient_id" # column that identifies the patient + timestamp: null # no visit timestamp for ECG records + attributes: + - record_id # WFDB record stem, e.g. "HR00001" + - signal_file # absolute path to the .mat file + - age # integer years (parsed from # Age: header line) + - sex # "Male" or "Female" + - scp_codes # comma-separated SNOMED-CT code string, e.g. "426783006,251146004" +``` + +**Key design decisions:** +- `timestamp: null` — ECG recordings are single snapshots, not time-series visits. +- `signal_file` stores the **absolute** path so the task can load the file from any working directory. +- `scp_codes` is kept as a raw string; the task is responsible for parsing and mapping it. + +--- + +### 4.2 PTBXLDataset Class + +`PTBXLDataset` inherits from `BaseDataset` (PyHealth's Polars + LitData-backed dataset engine). + +``` +PTBXLDataset +│ +├── __init__(root, dataset_name, config_path, **kwargs) +│ Step 1: resolve config_path → configs/ptbxl.yaml +│ Step 2: call prepare_metadata() +│ Step 3: resolve effective_root (shared CSV vs cache CSV) +│ Step 4: super().__init__(root=effective_root, tables=["ptbxl"], ...) +│ +├── prepare_metadata() ← Scans .hea files, builds ptbxl-pyhealth.csv +│ +└── default_task (property) ← Returns PTBXLMultilabelClassification( + label_type="superdiagnostic", sampling_rate=100) +``` + +--- + +### 4.3 `prepare_metadata` Flow + +This is the most complex operation in the dataset class. It runs once on first use and is idempotent thereafter. + +```mermaid +flowchart TD + START([prepare_metadata called]) --> CHECK{CSV exists at\nroot/ or ~/.cache/?} + CHECK -- yes --> SKIP[Return early\n no-op] + CHECK -- no --> SCAN[Glob g*/ group dirs\nsorted alphabetically] + + SCAN --> FOR_GROUP[For each group_dir] + FOR_GROUP --> FOR_HEA[For each .hea file] + FOR_HEA --> MAT_CHECK{.mat file\nexists?} + MAT_CHECK -- no --> WARN_MAT[Log warning\nSkip record] + MAT_CHECK -- yes --> PARSE[Parse .hea header\nExtract Age / Sex / Dx] + PARSE --> APPEND[Append row to list\npatient_id, record_id,\nsignal_file, age, sex, scp_codes] + APPEND --> MORE_HEA{More .hea\nfiles?} + MORE_HEA -- yes --> FOR_HEA + MORE_HEA -- no --> MORE_GROUP{More group\ndirs?} + MORE_GROUP -- yes --> FOR_GROUP + MORE_GROUP -- no --> EMPTY{rows list\nempty?} + EMPTY -- yes --> ERROR[Raise RuntimeError\nNo .hea files found] + EMPTY -- no --> SORT["Sort by patient_id\npd.DataFrame → reset_index"] + SORT --> WRITE_TRY{Try writing\nroot/ptbxl-pyhealth.csv} + WRITE_TRY -- success --> DONE([Done]) + WRITE_TRY -- PermissionError/OSError --> FALLBACK[Write to\n~/.cache/pyhealth/ptbxl/\nptbxl-pyhealth.csv] + FALLBACK --> DONE + + style ERROR fill:#e74c3c,color:#fff + style DONE fill:#27ae60,color:#fff +``` + +--- + +### 4.4 Header Parsing + +Each `.hea` (WFDB header) file contains plain-text comment lines. The parser extracts three of them: + +``` +HR00001 12 500 5000 ← WFDB signal header (ignored except record ID from filename) +# Age: 56 ← parsed → age = 56 +# Sex: Female ← parsed → sex = "Female" +# Dx: 426783006,251146004 ← parsed → scp_codes = "426783006,251146004" +``` + +**Parsing logic (pseudocode):** +``` +for line in hea_file.splitlines(): + if line starts with "# Age:": + age = int(float(line.after(":"))) # float() handles "56.0" edge cases + if line starts with "# Sex:": + sex = line.after(":") + if line starts with "# Dx:": + scp_codes = line.after(":") # raw comma-separated string +``` + +**Resulting CSV rows (example):** + +| patient_id | record_id | signal_file | age | sex | scp_codes | +|---|---|---|---|---|---| +| HR00001 | HR00001 | /data/.../HR00001.mat | 56 | Female | 426783006,251146004 | +| HR00002 | HR00002 | /data/.../HR00002.mat | 42 | Male | 270492004 | + +> **Why `patient_id == record_id`?** +> The Challenge 2020 PTB-XL files do not embed an explicit patient ID in the header — each recording file is treated as an independent sample. Setting both columns to the record stem (`HR00001`) lets `BaseDataset` build a one-patient-per-recording data model without special casing. + +--- + +### 4.5 Dataset → BaseDataset Sequence + +```mermaid +sequenceDiagram + actor User + participant PTBXLDataset + participant prepare_metadata + participant BaseDataset + participant Polars + participant LitData + + User->>PTBXLDataset: PTBXLDataset(root="/data/.../ptb-xl/") + PTBXLDataset->>prepare_metadata: prepare_metadata() + prepare_metadata-->>PTBXLDataset: ptbxl-pyhealth.csv written (or already existed) + + PTBXLDataset->>BaseDataset: super().__init__(root, tables=["ptbxl"], config_path) + BaseDataset->>Polars: Read ptbxl-pyhealth.csv via YAML schema + Polars-->>BaseDataset: Polars DataFrame (one row per recording) + BaseDataset->>LitData: Serialize patient objects → global_event_df.parquet (cache) + LitData-->>BaseDataset: Cache ready + BaseDataset-->>PTBXLDataset: Initialisation complete + PTBXLDataset-->>User: dataset object ready + + User->>PTBXLDataset: dataset.stats() + PTBXLDataset-->>User: "21837 patients, 21837 visits, ..." + + User->>PTBXLDataset: patient = dataset.get_patient("HR00001") + PTBXLDataset-->>User: Patient(patient_id="HR00001", events=[...]) +``` + +--- + +## 5. Stage 2 — Task Implementation + +### 5.1 Label Space Definitions + +The task supports two label vocabularies. Both are defined as Python-level constants in `ptbxl_multilabel_classification.py`. + +#### Superdiagnostic (5 classes) + +```mermaid +graph LR + SNOMED["Many SNOMED-CT codes\nfrom # Dx: field"] + SNOMED -->|"426783006"| NORM["NORM\nNormal sinus rhythm"] + SNOMED -->|"57054005\n164865005\n413444003\n..."| MI["MI\nMyocardial Infarction"] + SNOMED -->|"164931005\n164934002\n59931005\n..."| STTC["STTC\nST/T-wave Change"] + SNOMED -->|"270492004\n164889003\n164909002\n..."| CD["CD\nConduction Disturbance"] + SNOMED -->|"55827005\n39732003\n251146004\n..."| HYP["HYP\nHypertrophy / Axis Deviation"] + + style NORM fill:#3498db,color:#fff + style MI fill:#e74c3c,color:#fff + style STTC fill:#f39c12,color:#fff + style CD fill:#9b59b6,color:#fff + style HYP fill:#1abc9c,color:#fff +``` + +The mapping `SNOMED_TO_SUPERDIAG` covers **53 SNOMED-CT codes** collapsed to 5 classes. + +#### Diagnostic (27 classes) + +The 27 SNOMED-CT codes officially scored in the PhysioNet / CinC Challenge 2020: + +| Code | Abbreviation | Condition | +|---|---|---| +| 270492004 | IAVB | First-degree AV block | +| 164889003 | AF | Atrial fibrillation | +| 164890007 | AFL | Atrial flutter | +| 6374002 | BBB | Bundle branch block | +| 426627000 | Brady | Bradycardia | +| 713427006 | CRBBB | Complete right BBB | +| 713426002 | CLBBB | Complete left BBB | +| 445118002 | LAnFB | Left anterior fascicular block | +| 39732003 | LAD | Left axis deviation | +| 164909002 | LBBB | Left bundle branch block | +| 251146004 | LQRSV | Low QRS voltage | +| 698252002 | NSIVCB | Non-specific IVCD | +| 10370003 | PR | Pacing rhythm | +| 164947007 | LPR | Prolonged PR interval | +| 164917005 | LQT | Prolonged QT interval | +| 47665007 | RAD | Right axis deviation | +| 427393009 | SA | Sinus arrhythmia | +| 426177001 | SB | Sinus bradycardia | +| 426783006 | NSR | Normal sinus rhythm | +| 427084000 | ST | Sinus tachycardia | +| 63593006 | SVPB | Supraventricular premature beats | +| 164934002 | STD | ST depression | +| 59931005 | TWA | T-wave abnormality | +| 164931005 | STE | ST elevation | +| 17338001 | VPB | Ventricular premature beats | +| 284470004 | PAC | Premature atrial contraction | +| 427172004 | PVC | Premature ventricular contraction | + +--- + +### 5.2 PTBXLMultilabelClassification Class + +``` +PTBXLMultilabelClassification(BaseTask) +│ +├── Class-level schema constants +│ task_name : str = "PTBXLMultilabelClassification" (overridden in __init__) +│ input_schema: dict = {"signal": "tensor"} → TensorProcessor +│ output_schema: dict = {"labels": "multilabel"} → MultiLabelProcessor +│ +├── __init__(sampling_rate=100, label_type="superdiagnostic") +│ Validates: sampling_rate ∈ {100, 500} +│ Validates: label_type ∈ {"superdiagnostic", "diagnostic"} +│ Sets unique task_name to avoid cache collisions: +│ "PTBXLSuperDiagnostic_100Hz" +│ "PTBXLSuperDiagnostic_500Hz" +│ "PTBXLDiagnostic27_100Hz" +│ "PTBXLDiagnostic27_500Hz" +│ +└── __call__(patient: Patient) → List[Dict] + Per-patient sample extraction (see next section) +``` + +--- + +### 5.3 `__call__` Flow per Patient + +`BaseDataset.set_task(task)` calls `task(patient)` for every patient. In PTB-XL each patient has exactly one event (one recording), so each call returns at most one sample. + +```mermaid +flowchart TD + START(["task(patient) called"]) --> GET_EVENTS["events = patient.get_events(event_type='ptbxl')"] + GET_EVENTS --> FOR_EVENT[For each event] + FOR_EVENT --> CHECK_FILE{signal_file\nattribute set?} + + CHECK_FILE -- no --> SKIP1[Skip → debug log] + CHECK_FILE -- yes --> LOAD["loadmat(signal_file)\n→ mat['val'] shape: 12×5000"] + LOAD --> LOAD_OK{loadmat\nsucceeded?} + LOAD_OK -- no --> SKIP2[Skip → warning log] + LOAD_OK -- yes --> SHAPE{signal.ndim==2\nand shape[0]==12?} + SHAPE -- no --> SKIP3[Skip → warning log] + SHAPE -- yes --> RESAMPLE{sampling_rate\n== 100?} + RESAMPLE -- yes --> DECIMATE["signal = signal[:, ::5]\nshape: 12×1000"] + RESAMPLE -- no --> KEEP["signal unchanged\nshape: 12×5000"] + + DECIMATE --> PARSE_CODES + KEEP --> PARSE_CODES + + PARSE_CODES["Parse scp_codes string\n'426783006,251146004' → ['426783006','251146004']"] + PARSE_CODES --> LABEL_TYPE{label_type?} + + LABEL_TYPE -- superdiagnostic --> MAP5["Map codes via SNOMED_TO_SUPERDIAG\nlabels = set of NORM/MI/STTC/CD/HYP"] + LABEL_TYPE -- diagnostic --> MAP27["Filter codes ∈ CHALLENGE_SNOMED_CLASSES\nlabels = matching SNOMED strings"] + + MAP5 --> EMPTY_LABELS{labels\nempty?} + MAP27 --> EMPTY_LABELS + EMPTY_LABELS -- yes --> SKIP4[Skip record] + EMPTY_LABELS -- no --> APPEND_SAMPLE["samples.append\n{'signal': ndarray, 'labels': List[str]}"] + + SKIP1 --> NEXT_EVENT{More events?} + SKIP2 --> NEXT_EVENT + SKIP3 --> NEXT_EVENT + SKIP4 --> NEXT_EVENT + APPEND_SAMPLE --> NEXT_EVENT + + NEXT_EVENT -- yes --> FOR_EVENT + NEXT_EVENT -- no --> RETURN(["return samples"]) + + style SKIP1 fill:#e0e0e0 + style SKIP2 fill:#e0e0e0 + style SKIP3 fill:#e0e0e0 + style SKIP4 fill:#e0e0e0 + style RETURN fill:#27ae60,color:#fff +``` + +--- + +### 5.4 Decimation: 500 Hz → 100 Hz + +The raw PTB-XL signals are recorded at **500 Hz** — 5,000 samples per 10-second lead. When `sampling_rate=100`, the task decimates by a factor of 5 using simple stride slicing: + +``` +Native signal: X ∈ ℝ^{12 × 5000} (500 Hz) + ↓ signal[:, ::5] +Decimated: X ∈ ℝ^{12 × 1000} (100 Hz) +``` + +This is **no-filter decimation** (take every 5th sample). It is fast and avoids a scipy dependency in the hot path, matching the practice in Strodthoff *et al.* (2021). Proper anti-aliasing (e.g., `scipy.signal.decimate`) could be used for production quality but is not required for this ablation study. + +``` +Time axis: [t₀, t₁, t₂, t₃, t₄, t₅, t₆, t₇, t₈, t₉, t₁₀, ...] + ↑ 5000 samples +Keep: [t₀, t₅, t₁₀, t₁₅, ...] + ↑ 1000 samples +``` + +--- + +## 6. Mathematical Framing + +### 6.1 Signal Representation + +Each ECG recording is a 2-D tensor with 12 leads and T time steps: + +$$X \in \mathbb{R}^{C \times T}, \quad C = 12, \quad T \in \{1000, 5000\}$$ + +The ground-truth annotation for that recording is a **multi-hot binary vector**: + +$$y \in \{0, 1\}^K, \quad K \in \{5, 27\}$$ + +where $y_k = 1$ if class $k$ is present in the recording and $y_k = 0$ otherwise. Multiple classes can be 1 simultaneously (hence "multi-label"). + +--- + +### 6.2 Forward Pass + +The SparcNet backbone $f_\theta$ maps the signal to a feature embedding, which a linear head then projects to $K$ logit scores: + +$$\hat{y} = \sigma\!\left(f_\theta(X)\,W^\top + b\right) \in [0,1]^K$$ + +where $\sigma(z) = 1/(1 + e^{-z})$ is the element-wise sigmoid, $W \in \mathbb{R}^{K \times d}$ is the output weight matrix ($d$ = embedding dimension), and $b \in \mathbb{R}^K$ is the bias vector. + +Each output $\hat{y}_k$ is the predicted **probability** that class $k$ is present. + +--- + +### 6.3 Loss Function + +Training uses the **element-wise Binary Cross-Entropy** loss (BCE), summed independently per class: + +$$\mathcal{L}_{\text{BCE}} = -\frac{1}{K}\sum_{k=1}^{K}\Big[y_k\log\hat{y}_k + (1 - y_k)\log(1 - \hat{y}_k)\Big]$$ + +BCE is appropriate for multi-label problems because each output neuron is an independent binary classifier. Unlike cross-entropy for multi-class, the $K$ outputs do **not** share a softmax normalisation — they are modelled as $K$ independent Bernoulli random variables. + +PyHealth's `BaseModel.get_loss_function()` automatically returns `F.binary_cross_entropy_with_logits` when `output_schema["labels"] = "multilabel"` — which is applied to raw logits (before sigmoid) for numerical stability. + +--- + +### 6.4 Evaluation Metrics + +#### Macro ROC-AUC + +For each class $k$, the **Receiver Operating Characteristic** (ROC) curve is traced by varying the threshold $t$ and plotting: + +$$\text{TPR}_k(t) = \frac{\text{TP}_k(t)}{\text{TP}_k(t) + \text{FN}_k(t)}, \quad \text{FPR}_k(t) = \frac{\text{FP}_k(t)}{\text{FP}_k(t) + \text{TN}_k(t)}$$ + +The AUC for class $k$ is the area under this curve: + +$$\text{AUC}_k = \int_0^1 \text{TPR}_k(t)\,d\,\text{FPR}_k(t)$$ + +Macro-averaging gives equal weight to all classes regardless of prevalence: + +$$\overline{\text{AUC}} = \frac{1}{K}\sum_{k=1}^{K}\text{AUC}_k$$ + +An AUC of 0.5 corresponds to random guessing; 1.0 is perfect. + +#### Macro F1 + +At a fixed threshold of 0.5, we convert $\hat{y}_k$ to binary predictions and compute per-class F1: + +$$F_{1,k} = \frac{2\,\text{TP}_k}{2\,\text{TP}_k + \text{FP}_k + \text{FN}_k}$$ + +$$\overline{F_1} = \frac{1}{K}\sum_{k=1}^{K}F_{1,k}$$ + +F1 is more sensitive to class imbalance than AUC and penalises both false positives and false negatives. + +--- + +## 7. Ablation Study Design + +The ablation varies **two independent axes** and holds all training hyper-parameters constant: + +``` +label_type × sampling_rate → 2 × 2 = 4 configurations +``` + +```mermaid +quadrantChart + title Ablation Grid: Label Granularity vs Temporal Resolution + x-axis "Coarse labels (5-class)" --> "Fine labels (27-class)" + y-axis "Low resolution (100 Hz)" --> "High resolution (500 Hz)" + quadrant-1 Hard + High-Res + quadrant-2 Baseline + High-Res + quadrant-3 Baseline (default) + quadrant-4 Hard + Low-Res + Config A: [0.1, 0.1] + Config B: [0.1, 0.9] + Config C: [0.9, 0.1] + Config D: [0.9, 0.9] +``` + +| Config | `label_type` | `sampling_rate` | $K$ | $T$ | Expected AUC trend | +|---|---|---|---|---|---| +| **A** (baseline) | superdiagnostic | 100 Hz | 5 | 1 000 | Highest (easiest) | +| **B** | superdiagnostic | 500 Hz | 5 | 5 000 | ≥ A (more info) | +| **C** | diagnostic | 100 Hz | 27 | 1 000 | < A (harder task) | +| **D** | diagnostic | 500 Hz | 27 | 5 000 | ≤ B, ≥ C (trade-off) | + +**Hyper-parameters fixed across all configs** (from the paper's grid search): + +| Parameter | Value | +|---|---| +| Batch size | 64 | +| Learning rate | 0.001 (Adam) | +| Epochs | 5 (smoke test) / 20–30 (full repro) | +| Split | 70 / 10 / 20 % (train / val / test, by patient) | +| Monitor metric | macro ROC-AUC (validation) | +| Model | SparcNet (DenseNet-style 1-D CNN) | + +**Why SparcNet?** +SparcNet's dense-block architecture with successive max-pooling layers produces a receptive field that grows proportionally with $T$, making it naturally suited to comparing signals of different lengths (1 000 vs 5 000). + +--- + +## 8. Module Registration (`__init__` imports) + +Both the dataset and task must be exported from their package's `__init__.py` so users can write `from pyhealth.datasets import PTBXLDataset` without knowing the internal module path. + +### `pyhealth/datasets/__init__.py` (existing line 83) + +```python +from .ptbxl import PTBXLDataset +``` + +### `pyhealth/tasks/__init__.py` (existing line 69) + +```python +from .ptbxl_multilabel_classification import PTBXLMultilabelClassification +``` + +These lines were **already present** in the repository (written as part of the initial implementation). + +--- + +## 9. Documentation (RST + toctree) + +PyHealth uses [Sphinx](https://www.sphinx-doc.org/) with `autoclass` directives to auto-generate API reference from docstrings. + +### Dataset RST (`docs/api/datasets/pyhealth.datasets.PTBXLDataset.rst`) + +```rst +pyhealth.datasets.PTBXLDataset +============================== + +PTB-XL is a publically available electrocardiography dataset... + +.. autoclass:: pyhealth.datasets.PTBXLDataset + :members: + :undoc-members: + :show-inheritance: +``` + +This file **already existed** at line 241 of `datasets.rst`: +```rst +datasets/pyhealth.datasets.PTBXLDataset +``` + +### Task RST (`docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst`) — **newly created** + +```rst +pyhealth.tasks.PTBXLMultilabelClassification +============================================ + +PTB-XL is a large publicly available 12-lead ECG dataset... +Two label spaces are supported via the ``label_type`` argument... + +.. autoclass:: pyhealth.tasks.PTBXLMultilabelClassification + :members: + :undoc-members: + :show-inheritance: +``` + +### `docs/api/tasks.rst` toctree — **line added** + +```rst + PTB-XL Multi-Label ECG Classification +``` + +--- + +## 10. Test Suite + +### 10.1 Test Architecture + +```mermaid +classDiagram + class TestPTBXLDataset { + +_make_ds(root) PTBXLDataset + +test_prepare_metadata_basic() + +test_prepare_metadata_multiple_groups() + +test_prepare_metadata_skips_missing_mat() + +test_prepare_metadata_idempotent() + +test_prepare_metadata_no_records_raises() + +test_default_task_returns_superdiagnostic_instance() + } + + class TestPTBXLMultilabelClassification { + +_make_mat_file(tmp_dir, name, signal) str + +_make_patient(signal_file, scp_codes) _FakePatient + +test_invalid_sampling_rate_raises() + +test_invalid_label_type_raises() + +test_task_names_are_unique() + +test_superdiagnostic_100hz_signal_shape() + +test_superdiagnostic_500hz_signal_shape() + +test_signal_dtype_is_float32() + +test_superdiagnostic_normal_label() + +test_superdiagnostic_multilabel() + +test_superdiagnostic_no_known_codes_skipped() + +test_diagnostic_known_challenge_code() + +test_diagnostic_non_challenge_code_skipped() + +test_diagnostic_multiple_valid_codes() + +test_missing_signal_file_returns_empty() + +test_nonexistent_signal_file_returns_empty() + +test_empty_patient_no_events() + +test_wrong_signal_shape_skipped() + +test_superdiag_classes_count() + +test_challenge_classes_count() + +test_snomed_to_superdiag_values() + } + + class _FakeEvent { + +signal_file: str + +scp_codes: str + +age: int + +sex: str + } + + class _FakePatient { + +patient_id: str + +get_events(event_type) List + } + + TestPTBXLMultilabelClassification --> _FakePatient + _FakePatient --> _FakeEvent +``` + +**Total: 18 + 3 (constant checks) = ~21 assertions** across the two test classes. + +**Design principle:** All tests are **fully offline** — no network, no real ECG data. Fake filesystems use Python's `tempfile.TemporaryDirectory` and `scipy.io.savemat` to write real-format `.mat` files into memory. + +--- + +### 10.2 Dataset Tests + +```mermaid +sequenceDiagram + participant Test + participant tempfile + participant PTBXLDataset + participant Filesystem + + Test->>tempfile: TemporaryDirectory() + tempfile-->>Test: tmp path + + Test->>Filesystem: mkdir g1/ + Test->>Filesystem: write HR00001.hea (with Age, Sex, Dx) + Test->>Filesystem: write HR00001.mat (zero-byte placeholder) + + Test->>PTBXLDataset: PTBXLDataset.__new__(PTBXLDataset) + Note over Test,PTBXLDataset: Bypass BaseDataset.__init__ + Test->>PTBXLDataset: ds.root = tmp_path + Test->>PTBXLDataset: ds.prepare_metadata() + PTBXLDataset->>Filesystem: Scan g*/*.hea files + PTBXLDataset->>Filesystem: Write ptbxl-pyhealth.csv + PTBXLDataset-->>Test: Done + + Test->>Filesystem: pd.read_csv("ptbxl-pyhealth.csv") + Filesystem-->>Test: DataFrame + Test->>Test: assert len(df) == expected + Test->>Test: assert df columns present + Test->>Test: assert age / sex / scp_codes values +``` + +**Test cases for `TestPTBXLDataset`:** + +| Test | What it verifies | +|---|---| +| `test_prepare_metadata_basic` | CSV is created with correct schema + values for a 2-record dataset | +| `test_prepare_metadata_multiple_groups` | Records across g1, g2, g3 all appear | +| `test_prepare_metadata_skips_missing_mat` | Records where `.mat` is absent are silently skipped | +| `test_prepare_metadata_idempotent` | Calling twice neither crashes nor duplicates rows | +| `test_prepare_metadata_no_records_raises` | Empty group dir → `RuntimeError` | +| `test_default_task_returns_superdiagnostic_instance` | `default_task` property returns the right task type | + +--- + +### 10.3 Task Tests + +```mermaid +sequenceDiagram + participant Test + participant scipy_savemat + participant _FakePatient + participant PTBXLMultilabelClassification + + Test->>scipy_savemat: savemat(path, {"val": np.zeros((12,5000), float32)}) + scipy_savemat-->>Test: .mat file written to temp dir + + Test->>_FakePatient: _FakePatient("p001", [_FakeEvent(signal_file, scp_codes)]) + Note over _FakePatient: Simulates pyhealth.data.Patient without BaseDataset + + Test->>PTBXLMultilabelClassification: task = PTBXLMultilabelClassification(label_type, sampling_rate) + Test->>PTBXLMultilabelClassification: samples = task(fake_patient) + + PTBXLMultilabelClassification->>scipy_savemat: loadmat(signal_file) → mat["val"] + scipy_savemat-->>PTBXLMultilabelClassification: array shape (12, 5000) + Note over PTBXLMultilabelClassification: Decimate if sampling_rate==100 + Note over PTBXLMultilabelClassification: Parse scp_codes → map labels + + PTBXLMultilabelClassification-->>Test: [{"signal": ndarray, "labels": [...]}] + + Test->>Test: assert sample["signal"].shape == (12, expected_T) + Test->>Test: assert "NORM" in sample["labels"] + Test->>Test: assert sample["signal"].dtype == float32 +``` + +**Test cases for `TestPTBXLMultilabelClassification`:** + +| Test | What it verifies | +|---|---| +| `test_invalid_sampling_rate_raises` | `sampling_rate=250` raises `ValueError` | +| `test_invalid_label_type_raises` | `label_type="morphological"` raises `ValueError` | +| `test_task_names_are_unique` | All 4 configs produce distinct `task_name` strings | +| `test_superdiagnostic_100hz_signal_shape` | Output shape is `(12, 1000)` at 100 Hz | +| `test_superdiagnostic_500hz_signal_shape` | Output shape is `(12, 5000)` at 500 Hz | +| `test_signal_dtype_is_float32` | Signal is cast to `float32` even if input was `float64` | +| `test_superdiagnostic_normal_label` | Code `426783006` → label `"NORM"` | +| `test_superdiagnostic_multilabel` | Codes `164889003,251146004` → labels `{"CD", "HYP"}` | +| `test_superdiagnostic_no_known_codes_skipped` | Unknown code → empty sample list | +| `test_diagnostic_known_challenge_code` | Challenge code `270492004` → label `"270492004"` | +| `test_diagnostic_non_challenge_code_skipped` | Non-challenge code → empty sample list | +| `test_diagnostic_multiple_valid_codes` | Two challenge codes → both appear in labels | +| `test_missing_signal_file_returns_empty` | `signal_file=""` → `[]` | +| `test_nonexistent_signal_file_returns_empty` | Bad path → `[]` (exception caught) | +| `test_empty_patient_no_events` | Patient with 0 events → `[]` | +| `test_wrong_signal_shape_skipped` | `(1, 5000)` shape → skipped | +| `test_superdiag_classes_count` | `SUPERDIAG_CLASSES` has exactly 5 members | +| `test_challenge_classes_count` | `CHALLENGE_SNOMED_CLASSES` has exactly 27 members | +| `test_snomed_to_superdiag_values` | All dict values are in `{"NORM","MI","STTC","CD","HYP"}` | + +--- + +## 11. Example Notebook — Ablation Study + +**File:** `examples/ptbxl_superdiagnostic_sparcnet.ipynb` + +The notebook runs the full PyHealth pipeline for all 4 ablation configs and produces a comparative bar chart. + +### 11.1 End-to-End Pipeline Sequence + +```mermaid +sequenceDiagram + actor User + participant Notebook + participant PTBXLDataset + participant SampleDataset + participant SparcNet + participant Trainer + participant Metrics + + User->>Notebook: Set PTBXL_ROOT, BATCH_SIZE, LR, EPOCHS + + Notebook->>PTBXLDataset: PTBXLDataset(root=PTBXL_ROOT, dev=DEV_MODE) + PTBXLDataset-->>Notebook: base_dataset (21 837 recordings) + + loop For each of 4 ablation configs (A, B, C, D) + Notebook->>Notebook: task = PTBXLMultilabelClassification(label_type, sampling_rate) + Notebook->>PTBXLDataset: sample_ds = base_dataset.set_task(task) + Note over PTBXLDataset: For each patient: task(patient) → samples + PTBXLDataset-->>Notebook: SampleDataset (LitData-backed, indexable) + + Notebook->>SampleDataset: split_by_patient(sample_ds, [0.7, 0.1, 0.2]) + SampleDataset-->>Notebook: train_ds, val_ds, test_ds + + Notebook->>SparcNet: SparcNet(dataset=sample_ds) + Note over SparcNet: Reads input shape from sample_ds[0]["signal"] + SparcNet-->>Notebook: model + + Notebook->>Trainer: Trainer(model, device=DEVICE, metrics=[...]) + Notebook->>Trainer: trainer.train(train_loader, val_loader, epochs=EPOCHS, monitor="roc_auc_macro") + Note over Trainer: Each epoch: forward → BCE loss → Adam step → val eval + Trainer-->>Notebook: Best model checkpoint saved + + Notebook->>Trainer: trainer.evaluate(test_loader) + Trainer->>Metrics: multilabel_metrics_fn(y_true, y_prob, metrics=[...]) + Metrics-->>Trainer: {"roc_auc_macro": ..., "f1_macro": ...} + Trainer-->>Notebook: test_metrics dict + + Notebook->>Notebook: Append to results list + end + + Notebook->>Notebook: pd.DataFrame(results).display() + Notebook->>Notebook: matplotlib bar chart → ptbxl_ablation_results.png +``` + +### Key code pattern repeated for each config + +```python +# 1. Task definition +task = PTBXLMultilabelClassification(label_type="superdiagnostic", sampling_rate=100) + +# 2. Apply to dataset → SampleDataset +sample_ds = base_dataset.set_task(task) + +# 3. Split by patient (no data leakage) +train_ds, val_ds, test_ds = split_by_patient(sample_ds, [0.7, 0.1, 0.2]) + +# 4. Model from dataset schema +model = SparcNet(dataset=sample_ds) # auto-infers C=12, T=1000 + +# 5. Train +trainer = Trainer(model=model, device=DEVICE) +trainer.train(train_loader, val_loader, epochs=5, monitor="roc_auc_macro") + +# 6. Evaluate +metrics = trainer.evaluate(test_loader) +# → {"roc_auc_macro": 0.92, "f1_macro": 0.74, ...} +``` + +--- + +## 12. Data Layout + +``` +classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/ +└── training/ + └── ptb-xl/ ← pass this as root=... + ├── g1/ + │ ├── HR00001.hea ← WFDB header (ASCII, ~10 lines) + │ ├── HR00001.mat ← MATLAB signal matrix, 12×5000 float16 + │ ├── HR00002.hea + │ ├── HR00002.mat + │ └── ... ← ~1000 pairs per group + ├── g2/ + │ └── HR01001.hea / .mat + ├── ... + └── g22/ ← 22 groups total +``` + +After `prepare_metadata()` runs: + +``` +training/ptb-xl/ +└── ptbxl-pyhealth.csv ← Auto-generated index (21 837 rows) + columns: patient_id, record_id, signal_file, age, sex, scp_codes +``` + +After `set_task()` runs (first time): + +``` +~/.cache/pyhealth/ptbxl/ ← or custom cache_dir= +└── PTBXLSuperDiagnostic_100Hz/ ← one folder per task_name + ├── global_event_df.parquet + └── *.ld ← LitData binary shards +``` + +--- + +## 13. Dependency Graph + +```mermaid +graph TD + subgraph External["External Data"] + HEA[".hea WFDB headers"] + MAT[".mat signal matrices\n12 × 5000 float16"] + end + + subgraph Dataset["Dataset Layer (Stage 1)"] + YAML["ptbxl.yaml\nTable schema"] + META["prepare_metadata()\n→ ptbxl-pyhealth.csv"] + PTBXLDS["PTBXLDataset\n(BaseDataset)"] + end + + subgraph Task["Task Layer (Stage 2)"] + MAP5["SNOMED_TO_SUPERDIAG\n53 codes → 5 classes"] + MAP27["CHALLENGE_SNOMED_CLASSES\n27 codes"] + TASK["PTBXLMultilabelClassification\n(BaseTask)"] + end + + subgraph SampleDS["SampleDataset (set_task output)"] + SAMP["SampleDataset\n{'signal': tensor, 'labels': multi-hot}"] + end + + subgraph Model["Model Layer (Stage 3)"] + SPARCNET["SparcNet\n1-D DenseNet CNN"] + end + + subgraph Eval["Evaluation (Stage 5)"] + BCE["BCE Loss\n(training)"] + AUC["macro ROC-AUC\n(evaluation)"] + F1["macro F1\n(evaluation)"] + end + + HEA --> META + MAT --> META + YAML --> PTBXLDS + META --> PTBXLDS + + PTBXLDS -->|set_task| TASK + MAP5 --> TASK + MAP27 --> TASK + TASK --> SAMP + + SAMP --> SPARCNET + SPARCNET --> BCE + SPARCNET --> AUC + SPARCNET --> F1 + + style External fill:#ffeeba + style Dataset fill:#d4edda + style Task fill:#cce5ff + style SampleDS fill:#f8d7da + style Model fill:#e2d9f3 + style Eval fill:#fff3cd +``` + +--- + +## 14. References + +1. **Wagner, P. et al.** (2020). PTB-XL, a large publicly available electrocardiography dataset. *Scientific Data* 7, 154. https://doi.org/10.1038/s41597-020-0495-6 + +2. **Reyna, M.A. et al.** (2020). Will Two Do? Varying Dimensions in Electrocardiography: The PhysioNet/Computing in Cardiology Challenge 2020. *CinC 2020*. + +3. **Strodthoff, N. et al.** (2021). Deep Learning for ECG Analysis: Benchmarks and Insights from PTB-XL. *IEEE Journal of Biomedical and Health Informatics* 25(5), 1519–1528. + +4. **Jing, J. et al.** (2023). Development of Expert-Level Classification of Seizures and Rhythmic and Periodic Patterns During EEG Interpretation. *Neurology* 100, e1750–e1762. *(SparcNet paper)* + +5. **Zhao, M. et al.** (2024). PyHealth: A Deep Learning Toolkit for Healthcare Predictive Modeling. *arXiv:2401.06284*. + +--- + +*Document generated: April 8, 2026 | CS-598 DLH Project Team* diff --git a/cs598_project/ptbxl_pyhealth_pipeline.ipynb b/cs598_project/ptbxl_pyhealth_pipeline.ipynb new file mode 100644 index 000000000..3b9e7746b --- /dev/null +++ b/cs598_project/ptbxl_pyhealth_pipeline.ipynb @@ -0,0 +1,4645 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bb07c10", + "metadata": {}, + "source": [ + "# PTB-XL ECG Deep Learning Pipeline\n", + "## A Step-by-Step Explanation with Python Code and Flow Diagrams\n", + "\n", + "This notebook explains the full pipeline from raw ECG files on disk to a published, reproducible benchmark — the exact pipeline your CS-598 project proposes as a PyHealth contribution.\n", + "\n", + "```\n", + "Raw PTB-XL files on disk\n", + " ↓ PTBXLDataset.process_EEG_data()\n", + "Structured patient dictionary (18,885 patients × ECG records)\n", + " ↓ dataset.set_task(ptbxl_superdiagnostic_fn)\n", + "SampleDataset (list of windowed samples with multi-hot labels)\n", + " ↓ split_by_patient()\n", + "Train / Val / Test splits (no patient leakage)\n", + " ↓ PyHealth Trainer + your model\n", + "Trained DNN (ResNet1d, BiLSTM, Transformer...)\n", + " ↓ trainer.evaluate()\n", + "ROC-AUC macro + F1 macro scores ← reproducible benchmark\n", + " ↓\n", + "Published as a Colab notebook anyone can run\n", + "```\n", + "\n", + "Each section below: (1) explains what is happening conceptually, (2) shows the relevant Python code, and (3) renders a flow diagram for that stage." + ] + }, + { + "cell_type": "markdown", + "id": "3e5df7df", + "metadata": {}, + "source": [ + "---\n", + "## Section 1 — Install and Import Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "89ecd1c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ All imports successful\n", + " PyTorch : 2.8.0\n", + " Device : mps\n", + " PyHealth: 1.1.6\n" + ] + } + ], + "source": [ + "# ── Standard library & scientific stack ──────────────────────────────────────\n", + "import ast\n", + "import os\n", + "import pickle\n", + "import sys\n", + "import warnings\n", + "from collections import defaultdict\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import matplotlib.gridspec as gridspec\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from sklearn.metrics import roc_auc_score, f1_score\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# PyHealth — the medical-AI framework used throughout this notebook.\n", + "#\n", + "# Install once with: pip install pyhealth\n", + "#\n", + "# PyHealth components used:\n", + "# • BaseSignalDataset — abstract base class for signal (ECG/EEG) datasets\n", + "# • SampleSignalDataset — wraps List[Dict] of task samples, handles epoch_path\n", + "# • split_by_patient — patient-level train/val/test split (no leakage)\n", + "# • get_dataloader — converts a SampleSignalDataset subset into a PyTorch DataLoader\n", + "# • SparcNet — DenseNet-based 1D signal classification model\n", + "# • BaseModel — abstract base for building custom PyHealth-compatible models\n", + "# • Trainer — training loop with early stopping + evaluation\n", + "# • multilabel_metrics_fn — computes roc_auc_macro, f1_macro, etc.\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "from pyhealth.datasets import (\n", + " BaseSignalDataset,\n", + " SampleSignalDataset,\n", + " get_dataloader,\n", + " split_by_patient,\n", + ")\n", + "from pyhealth.models import BaseModel, SparcNet\n", + "from pyhealth.trainer import Trainer\n", + "from pyhealth.metrics import multilabel_metrics_fn\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning, module=\"dask\")\n", + "\n", + "print(\"✅ All imports successful\")\n", + "print(f\" PyTorch : {torch.__version__}\")\n", + "print(f\" Device : {'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'}\")\n", + "\n", + "try:\n", + " import pyhealth\n", + " print(f\" PyHealth: {pyhealth.__version__}\")\n", + "except Exception:\n", + " print(\" PyHealth: (version not exposed)\")\n", + "\n", + "DEVICE = \"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "ab11ed5f", + "metadata": {}, + "source": [ + "---\n", + "## Section 2 — Full Pipeline Flow Diagram\n", + "\n", + "Before diving in, look at the entire pipeline end-to-end. \n", + "Each box below corresponds to one section of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bdcff606", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 128190 (\\N{FLOPPY DISK}) missing from font(s) DejaVu Sans.\n", + " plt.tight_layout()\n", + "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 127959 (\\N{BUILDING CONSTRUCTION}) missing from font(s) DejaVu Sans.\n", + " plt.tight_layout()\n", + "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 127991 (\\N{LABEL}) missing from font(s) DejaVu Sans.\n", + " plt.tight_layout()\n", + "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 129504 (\\N{BRAIN}) missing from font(s) DejaVu Sans.\n", + " plt.tight_layout()\n", + "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 128202 (\\N{BAR CHART}) missing from font(s) DejaVu Sans.\n", + " plt.tight_layout()\n", + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 128190 (\\N{FLOPPY DISK}) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 127959 (\\N{BUILDING CONSTRUCTION}) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 127991 (\\N{LABEL}) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 129504 (\\N{BRAIN}) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 128202 (\\N{BAR CHART}) missing from font(s) DejaVu Sans.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def draw_pipeline_overview():\n", + " \"\"\"Draw a top-level pipeline overview showing all 8 stages.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(10, 16))\n", + " ax.set_xlim(0, 10)\n", + " ax.set_ylim(0, 16)\n", + " ax.axis(\"off\")\n", + " fig.patch.set_facecolor(\"#0d1117\")\n", + "\n", + " # ── Stage definitions ─────────────────────────────────────────────────────\n", + " stages = [\n", + " # (y_center, box_color, text_color, icon, title, subtitle, section)\n", + " (14.5, \"#1e3a5f\", \"white\", \"💾\", \"Raw PTB-XL Files on Disk\",\n", + " \"ptbxl_database.csv + 21,837 WFDB signal pairs\\n(.dat / .hea, 500 Hz, 10 s, 12 leads)\", \"§3\"),\n", + " (11.7, \"#1a4731\", \"white\", \"🏗️\", \"PTBXLDataset.process_EEG_data()\",\n", + " \"Groups all ECG records by patient_id\\n→ patients dict: {pid: [record, ...]}\", \"§4–5\"),\n", + " (8.9, \"#4a2f1a\", \"white\", \"🏷️\", \"dataset.set_task(ptbxl_superdiagnostic_fn)\",\n", + " \"Slides 2.5-s windows over each signal\\nMaps scp_codes → 5-class multi-hot label\\nSaves each window as .pkl → SampleDataset\", \"§6–7\"),\n", + " (6.1, \"#3b1f4a\", \"white\", \"✂️\", \"split_by_patient(ratios=[0.8, 0.1, 0.1])\",\n", + " \"Splits entire patients, not individual windows\\n→ zero patient overlap across Train/Val/Test\", \"§8\"),\n", + " (3.5, \"#4a1a1a\", \"white\", \"🧠\", \"PyHealth Trainer × Your DNN Model\",\n", + " \"ResNet1d / BiLSTM / Transformer\\nBCEWithLogitsLoss (multi-label)\\nEarly stop on macro ROC-AUC\", \"§9–10\"),\n", + " (1.0, \"#1a3a3a\", \"#00ffcc\",\"📊\", \"trainer.evaluate() → Metrics\",\n", + " \"ROC-AUC macro + F1 macro\\nPer-class ROC curves\\nReproducible benchmark numbers\", \"§11–12\"),\n", + " ]\n", + "\n", + " for (y, bg, fg, icon, title, subtitle, section) in stages:\n", + " # box\n", + " rect = plt.Rectangle((0.5, y - 1.0), 9.0, 1.8,\n", + " facecolor=bg, edgecolor=\"#ffffff44\",\n", + " linewidth=1.5, zorder=2)\n", + " ax.add_patch(rect)\n", + " # section badge\n", + " ax.text(9.2, y - 0.05, section, color=\"#aaaaaa\", fontsize=8,\n", + " ha=\"left\", va=\"center\", zorder=3)\n", + " # icon + title\n", + " ax.text(1.0, y + 0.45, icon + \" \" + title,\n", + " color=\"white\", fontsize=12, fontweight=\"bold\",\n", + " va=\"center\", ha=\"left\", zorder=3)\n", + " # subtitle\n", + " ax.text(1.0, y - 0.2, subtitle,\n", + " color=\"#bbbbbb\", fontsize=8.5, va=\"center\", ha=\"left\",\n", + " linespacing=1.6, zorder=3)\n", + "\n", + " # ── Arrows between boxes ──────────────────────────────────────────────────\n", + " arrow_y_pairs = [(13.5, 12.7), (10.7, 9.9), (7.9, 7.1), (5.1, 4.5), (2.5, 2.0)]\n", + " for (y1, y2) in arrow_y_pairs:\n", + " ax.annotate(\"\", xy=(5.0, y2), xytext=(5.0, y1),\n", + " arrowprops=dict(arrowstyle=\"-|>\", color=\"#00bfff\",\n", + " lw=2.0, mutation_scale=18),\n", + " zorder=4)\n", + "\n", + " ax.set_title(\"PTB-XL → PyHealth Pipeline — End to End\",\n", + " color=\"white\", fontsize=14, fontweight=\"bold\", pad=10)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "draw_pipeline_overview()" + ] + }, + { + "cell_type": "markdown", + "id": "be9593e6", + "metadata": {}, + "source": [ + "---\n", + "## Section 3 — Raw PTB-XL Files on Disk\n", + "\n", + "### What is PTB-XL?\n", + "PTB-XL (Wagner et al., 2020, PhysioNet) is the **largest publicly available clinical 12-lead ECG dataset**:\n", + "- **21,837 recordings** from **18,885 unique patients**\n", + "- Each recording: 10 seconds × 12 leads × 500 Hz = **60,000 samples per recording**\n", + "- Labels: physician-annotated SCP codes (e.g. `NORM`, `MI`, `AFIB`) with confidence scores\n", + "\n", + "### Directory structure on disk\n", + "\n", + "```\n", + "ptb-xl-1.0.1/\n", + "├── ptbxl_database.csv ← metadata for all 21,837 recordings\n", + "├── scp_statements.csv ← lookup: each SCP code → diagnostic class\n", + "├── records100/ ← 100 Hz versions of signals (WFDB format)\n", + "│ ├── 00000/\n", + "│ │ ├── 00001_lr.dat ← raw binary signal data\n", + "│ │ └── 00001_lr.hea ← header: leads, sample rate, calibration\n", + "│ └── ...\n", + "└── records500/ ← 500 Hz versions (used by the paper)\n", + " ├── 00000/\n", + " │ ├── 00001_hr.dat\n", + " │ └── 00001_hr.hea\n", + " └── ...\n", + "```\n", + "\n", + "### Key columns in `ptbxl_database.csv`\n", + "\n", + "| Column | Meaning |\n", + "|---|---|\n", + "| `ecg_id` | Unique recording ID (1–21837) |\n", + "| `patient_id` | Which patient (1–18885) — multiple ECGs per patient |\n", + "| `filename_hr` | Path to 500 Hz WFDB file relative to root |\n", + "| `filename_lr` | Path to 100 Hz WFDB file |\n", + "| `scp_codes` | Dict of `{SCP_code: confidence}` e.g. `{\"NORM\": 100.0}` |\n", + "| `strat_fold` | Cross-validation fold assignment (1–10) |\n", + "| `age`, `sex` | Patient demographics |" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ccc4653b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data format : ptbxl_wfdb\n", + "DB CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/ptbxl_database.csv ✅\n", + "WFDB root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB ✅\n", + "ptbxl_database.csv shape : (21799, 27)\n", + "Unique patients : 18,869\n", + "ECG recordings : 21,799\n", + "\n", + "First 3 rows (key columns):\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
patient_idagesexscp_codesstrat_fold
ecg_id
115709.056.01{'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}3
213243.019.00{'NORM': 80.0, 'SBRAD': 0.0}2
320372.037.01{'NORM': 100.0, 'SR': 0.0}5
\n", + "
" + ], + "text/plain": [ + " patient_id age sex scp_codes \\\n", + "ecg_id \n", + "1 15709.0 56.0 1 {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0} \n", + "2 13243.0 19.0 0 {'NORM': 80.0, 'SBRAD': 0.0} \n", + "3 20372.0 37.0 1 {'NORM': 100.0, 'SR': 0.0} \n", + "\n", + " strat_fold \n", + "ecg_id \n", + "1 3 \n", + "2 2 \n", + "3 5 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Signal file : HR00001.mat\n", + "Raw shape : (12, 5000) → (leads=12, samples=5000 @ 500 Hz)\n", + "Range (mV) : [-7.220, 3.450]\n", + "SCP codes : {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Shape: (12, 5000) (12 leads × 5000 samples @ 500 Hz = 10s)\n" + ] + } + ], + "source": [ + "import ast\n", + "import scipy.io\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pathlib import Path\n", + "\n", + "# ── Data roots ────────────────────────────────────────────────────────────────\n", + "_PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", + "_DB_CSV = _PROJECT_ROOT / \"ptbxl_database.csv\"\n", + "_WFDB_ROOT = _PROJECT_ROOT / \"WFDB\"\n", + "\n", + "_PTBXL_CINC = (\n", + " _PROJECT_ROOT.parent.parent /\n", + " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", + " / \"training\" / \"ptb-xl\"\n", + ")\n", + "\n", + "# ── Auto-detect best available format ─────────────────────────────────────────\n", + "if _DB_CSV.exists() and _WFDB_ROOT.is_dir():\n", + " DATA_FORMAT = \"ptbxl_wfdb\" # ptbxl_database.csv + WFDB/ flat .mat files\n", + "elif (_PTBXL_CINC / \"ptbxl-pyhealth.csv\").exists():\n", + " DATA_FORMAT = \"cinc2020\"\n", + "else:\n", + " DATA_FORMAT = \"synthetic\"\n", + "\n", + "print(f\"Data format : {DATA_FORMAT}\")\n", + "print(f\"DB CSV : {_DB_CSV} {'✅' if _DB_CSV.exists() else '❌'}\")\n", + "print(f\"WFDB root : {_WFDB_ROOT} {'✅' if _WFDB_ROOT.is_dir() else '❌'}\")\n", + "\n", + "LEAD_NAMES = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def demo_raw_files(fmt):\n", + " if fmt == \"ptbxl_wfdb\":\n", + " _demo_ptbxl_wfdb(_DB_CSV, _WFDB_ROOT)\n", + " elif fmt == \"cinc2020\":\n", + " _demo_cinc2020(_PTBXL_CINC)\n", + " else:\n", + " print(\"No real data found. Generating SYNTHETIC demo...\\n\")\n", + " _show_synthetic_structure()\n", + "\n", + "\n", + "def _demo_ptbxl_wfdb(db_csv: Path, wfdb_root: Path):\n", + " \"\"\"\n", + " Show metadata from ptbxl_database.csv and load a real signal\n", + " from the WFDB/ flat .mat folder (500 Hz, channel-first).\n", + " \"\"\"\n", + " df = pd.read_csv(db_csv, index_col=\"ecg_id\")\n", + " df[\"scp_codes\"] = df[\"scp_codes\"].apply(ast.literal_eval)\n", + "\n", + " print(f\"ptbxl_database.csv shape : {df.shape}\")\n", + " print(f\"Unique patients : {df['patient_id'].nunique():,}\")\n", + " print(f\"ECG recordings : {len(df):,}\\n\")\n", + " print(\"First 3 rows (key columns):\")\n", + " display(df[[\"patient_id\",\"age\",\"sex\",\"scp_codes\",\"strat_fold\"]].head(3))\n", + "\n", + " # Load signal: ecg_id → WFDB/HR{ecg_id:05d}.mat\n", + " ecg_id = df.index[0] # = 1\n", + " mat_path = wfdb_root / f\"HR{ecg_id:05d}.mat\"\n", + " data = scipy.io.loadmat(str(mat_path))\n", + " signal = data[\"val\"].astype(float) # shape: (12, 5000) channel-first, 500 Hz\n", + " # Convert ADC → mV: gain = 200 ADC units/mV (from .hea file)\n", + " signal_mv = signal / 200.0\n", + "\n", + " print(f\"\\nSignal file : {mat_path.name}\")\n", + " print(f\"Raw shape : {signal.shape} → (leads=12, samples=5000 @ 500 Hz)\")\n", + " print(f\"Range (mV) : [{signal_mv.min():.3f}, {signal_mv.max():.3f}]\")\n", + " print(f\"SCP codes : {df.loc[ecg_id, 'scp_codes']}\")\n", + " _plot_raw_signal(signal_mv, fs=500,\n", + " title=f\"PTB-XL 1.0.3 (WFDB flat .mat) — ECG #{ecg_id} \"\n", + " f\"Age={int(df.loc[ecg_id,'age'])} \"\n", + " f\"{'F' if df.loc[ecg_id,'sex']==1 else 'M'}\")\n", + "\n", + "\n", + "def _demo_cinc2020(root: Path):\n", + " \"\"\"Show metadata and a real signal from CinC 2020 PTB-XL challenge data.\"\"\"\n", + " df = pd.read_csv(root / \"ptbxl-pyhealth.csv\")\n", + " print(f\"ptbxl-pyhealth.csv shape : {df.shape}\")\n", + " print(f\"ECG recordings : {len(df):,}\\n\")\n", + " display(df[[\"patient_id\",\"record_id\",\"age\",\"sex\",\"scp_codes\",\"group\"]].head(3))\n", + "\n", + " row = df.iloc[0]\n", + " mat = scipy.io.loadmat(str(root / row[\"signal_file\"]))\n", + " signal = mat[\"val\"].astype(float) / 200.0 # ADC → mV\n", + " fs = int(row[\"sampling_rate\"])\n", + " print(f\"\\nSignal loaded (CinC .mat) : {signal.shape}\")\n", + " _plot_raw_signal(signal, fs, title=\"CinC 2020 PTB-XL — Real 12-lead ECG (500 Hz)\")\n", + "\n", + "\n", + "def _show_synthetic_structure():\n", + " t = np.linspace(0, 10, 5000)\n", + " ecg_sim = np.zeros((12, 5000))\n", + " for lead in range(12):\n", + " ecg_sim[lead] = (0.03 * np.sin(2*np.pi*1.2*t)\n", + " + 1.2 * np.exp(-((t % (1/1.2) - 0.15)**2) / 0.0002)\n", + " - 0.1 * np.sin(2*np.pi*1.2*t + 0.5)\n", + " + 0.01 * np.random.randn(5000))\n", + " _plot_raw_signal(ecg_sim, 500, title=\"SYNTHETIC 12-lead ECG (demo)\")\n", + "\n", + "\n", + "def _plot_raw_signal(signal, fs, title=\"12-lead ECG\"):\n", + " \"\"\"signal shape: (12, n_samples).\"\"\"\n", + " n = signal.shape[1]\n", + " fig, axes = plt.subplots(6, 2, figsize=(14, 9), sharex=True)\n", + " fig.suptitle(f\"{title} — shape {signal.shape} ({fs} Hz × {n//fs} s)\",\n", + " fontsize=11, fontweight=\"bold\")\n", + " axes_flat = axes.flatten()\n", + " for i in range(12):\n", + " axes_flat[i].plot(signal[i], linewidth=0.7, color=\"#1f77b4\")\n", + " axes_flat[i].set_ylabel(LEAD_NAMES[i], fontsize=8)\n", + " axes_flat[i].set_yticks([])\n", + " axes_flat[-1].set_xlabel(f\"Sample index (0–{n} @ {fs} Hz)\")\n", + " axes_flat[-2].set_xlabel(f\"Sample index (0–{n} @ {fs} Hz)\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " print(f\"\\n✅ Shape: {signal.shape} (12 leads × {n} samples @ {fs} Hz = {n//fs}s)\")\n", + "\n", + "\n", + "demo_raw_files(DATA_FORMAT)\n" + ] + }, + { + "cell_type": "markdown", + "id": "07b055f0", + "metadata": {}, + "source": [ + "---\n", + "## Section 4 — `PTBXLDataset.process_EEG_data()` — Pipeline Stage 1\n", + "\n", + "`process_EEG_data()` is the **only abstract method** you must implement when subclassing `BaseSignalDataset`. \n", + "Its job is to convert the raw files into a single structured dictionary.\n", + "\n", + "### What happens inside it — sub-flow\n", + "\n", + "```\n", + "ptbxl_database.csv\n", + " │\n", + " ▼\n", + "Read CSV → parse scp_codes column (string → dict)\n", + " │\n", + " ▼\n", + "For each row: build a record dict with wfdb_path, scp_codes, strat_fold, age, sex\n", + " │\n", + " ▼\n", + "Group records by patient_id (groupby)\n", + " │\n", + " ▼\n", + "Return patients = {\n", + " \"1\": [ {ecg_id:\"1\", wfdb_path:\"...\", scp_codes:{...}, strat_fold:9}, ... ],\n", + " \"2\": [ {ecg_id:\"2\", wfdb_path:\"...\", ...} ],\n", + " ...\n", + " \"18885\":[ ... ]\n", + "}\n", + "```\n", + "\n", + "**Key design principle:** `process_EEG_data()` does **NOT** load signal arrays — it only stores file paths. \n", + "Signal loading happens lazily, inside the task function (Section 6), so memory stays low." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f3bb5d93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialising PyHealth PTBXLDataset …\n", + "──────────────────────────────────────────────────────\n", + " PyHealth PTBXLDataset (BaseSignalDataset subclass)\n", + " Patients : 18,869\n", + " ECG records : 21,799\n", + " Avg ECGs/pt : 1.16\n", + " Strat folds : {1: 2175, 2: 2181, 3: 2192, 4: 2174, 5: 2174, 6: 2173, 7: 2176, 8: 2173, 9: 2183, 10: 2198}\n", + "──────────────────────────────────────────────────────\n" + ] + } + ], + "source": [ + "# ── STEP 4: PTBXLDataset — extends PyHealth's BaseSignalDataset ──────────────\n", + "#\n", + "# PyHealth's BaseSignalDataset is the standard abstract base class for any\n", + "# dataset that stores one signal (ECG, EEG, waveform) per patient.\n", + "#\n", + "# Subclass contract:\n", + "# • Override process_EEG_data() → return { patient_id: [record_dict, ...] }\n", + "# • Calling dataset.set_task(task_fn) iterates this dict, calls task_fn on\n", + "# each patient's records list, and returns a SampleSignalDataset.\n", + "#\n", + "# Key design: No signals are loaded here — only file paths are stored\n", + "# (lazy loading happens inside the task function).\n", + "\n", + "from scipy.io import loadmat as scipy_loadmat\n", + "\n", + "\n", + "class PTBXLDataset(BaseSignalDataset):\n", + " \"\"\"\n", + " PTB-XL 12-lead ECG dataset.\n", + "\n", + " Extends ``pyhealth.datasets.BaseSignalDataset`` so it is fully\n", + " compatible with PyHealth's Trainer, splitter, and model APIs.\n", + "\n", + " Directory layout expected::\n", + "\n", + " root/\n", + " ptbxl_database.csv\n", + " scp_statements.csv\n", + " WFDB/\n", + " HR00001.mat (12-lead ECG, 12×5000, 500 Hz)\n", + " HR00001.hea\n", + " HR00002.mat\n", + " ...\n", + "\n", + " Each ``WFDB/HR{:05d}.mat`` file stores the signal in\n", + " ``mat[\"val\"]`` (int16, ADC counts; divide by 200 to get mV).\n", + " \"\"\"\n", + "\n", + " def __init__(self, root: str, sampling_rate: int = 500, **kwargs):\n", + " self._ptbxl_root = Path(root)\n", + " self._sampling_rate = sampling_rate\n", + " # super().__init__ immediately calls process_EEG_data()\n", + " super().__init__(root=root, dataset_name=\"ptbxl\", **kwargs)\n", + "\n", + " def process_EEG_data(self) -> dict:\n", + " \"\"\"\n", + " Read ``ptbxl_database.csv`` and group ECG records by patient.\n", + "\n", + " Each patient entry stores:\n", + " patient_id – str\n", + " ecg_id – str (integer ecg_id from CSV)\n", + " mat_path – str (absolute path to WFDB/HR{id:05d}.mat)\n", + " scp_codes – dict {code: confidence_float}\n", + " strat_fold – int (1–10)\n", + " age / sex – float / int (demographics, optional)\n", + " \"\"\"\n", + " root = self._ptbxl_root\n", + " csv_path = root / \"ptbxl_database.csv\"\n", + "\n", + " if not csv_path.exists():\n", + " print(\"[PTBXLDataset] ptbxl_database.csv not found — using synthetic data.\")\n", + " return _build_synthetic_patients()\n", + "\n", + " df = pd.read_csv(csv_path, index_col=\"ecg_id\")\n", + " df[\"scp_codes\"] = df[\"scp_codes\"].apply(ast.literal_eval)\n", + " df[\"patient_id\"] = df[\"patient_id\"].astype(int).astype(str)\n", + "\n", + " patients = defaultdict(list)\n", + " wfdb_dir = root / \"WFDB\"\n", + "\n", + " for ecg_id, row in df.iterrows():\n", + " # Flat WFDB layout: WFDB/HR{ecg_id:05d}.mat\n", + " mat_path = wfdb_dir / f\"HR{int(ecg_id):05d}.mat\"\n", + " patients[row[\"patient_id\"]].append({\n", + " \"patient_id\": row[\"patient_id\"],\n", + " \"ecg_id\": str(ecg_id),\n", + " \"mat_path\": str(mat_path), # ← scipy.io.loadmat path\n", + " \"scp_codes\": row[\"scp_codes\"],\n", + " \"strat_fold\": int(row[\"strat_fold\"]),\n", + " \"age\": row.get(\"age\"),\n", + " \"sex\": row.get(\"sex\"),\n", + " })\n", + " return dict(patients)\n", + "\n", + " def stat(self):\n", + " total = sum(len(v) for v in self.patients.values())\n", + " folds = defaultdict(int)\n", + " for recs in self.patients.values():\n", + " for r in recs:\n", + " folds[r[\"strat_fold\"]] += 1\n", + " print(f\"{'─'*54}\")\n", + " print(f\" PyHealth PTBXLDataset (BaseSignalDataset subclass)\")\n", + " print(f\" Patients : {len(self.patients):,}\")\n", + " print(f\" ECG records : {total:,}\")\n", + " print(f\" Avg ECGs/pt : {total/len(self.patients):.2f}\")\n", + " print(f\" Strat folds : {dict(sorted(folds.items()))}\")\n", + " print(f\"{'─'*54}\")\n", + "\n", + "\n", + "def _build_synthetic_patients(n_patients: int = 200,\n", + " ecgs_per_max: int = 3) -> dict:\n", + " \"\"\"Minimal synthetic patients dict — same schema as real PTB-XL.\"\"\"\n", + " rng = np.random.default_rng(42)\n", + " DIAG = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"]\n", + " out = {}\n", + " ecg_id = 1\n", + " for pid in range(1, n_patients + 1):\n", + " n = rng.integers(1, ecgs_per_max + 1)\n", + " recs = []\n", + " for _ in range(n):\n", + " chosen = rng.choice(DIAG, size=rng.integers(1, 3), replace=False)\n", + " scp = {c: float(rng.integers(60, 101)) for c in chosen}\n", + " recs.append({\n", + " \"patient_id\": str(pid),\n", + " \"ecg_id\": str(ecg_id),\n", + " \"mat_path\": \"\", # no real file → synthetic signal\n", + " \"scp_codes\": scp,\n", + " \"strat_fold\": int((pid % 10) + 1),\n", + " \"age\": float(rng.integers(18, 85)),\n", + " \"sex\": int(rng.integers(0, 2)),\n", + " })\n", + " ecg_id += 1\n", + " out[str(pid)] = recs\n", + " return out\n", + "\n", + "\n", + "# ── Instantiate ───────────────────────────────────────────────────────────────\n", + "PTBXL_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", + "\n", + "print(\"Initialising PyHealth PTBXLDataset …\")\n", + "dataset = PTBXLDataset(root=str(PTBXL_ROOT), sampling_rate=500)\n", + "dataset.stat()\n" + ] + }, + { + "cell_type": "markdown", + "id": "0282d6e5", + "metadata": {}, + "source": [ + "---\n", + "## Section 5 — Inspect the Structured Patient Dictionary\n", + "\n", + "After `process_EEG_data()`, we have `dataset.patients` — a plain Python `dict`.\n", + "\n", + "```\n", + "dataset.patients = {\n", + " \"1\" : [ {ecg_id:\"1\", wfdb_path:\"...\", scp_codes:{\"NORM\":100.0}, strat_fold:9 , age:52, sex:0},\n", + " {ecg_id:\"12\", wfdb_path:\"...\", scp_codes:{\"NORM\":90.0}, strat_fold:9 , age:52, sex:0} ],\n", + " \"2\" : [ {ecg_id:\"3\", wfdb_path:\"...\", scp_codes:{\"MI\":80.0,\"ISCAL\":20.0}, strat_fold:7, ...} ],\n", + " ...\n", + " \"18885\" : [ ... ]\n", + "}\n", + "```\n", + "\n", + "**Why group by patient?** \n", + "Because when we later split into Train/Val/Test, we split **at the patient level** — \n", + "all ECGs from one patient stay together in the same split, preventing data leakage." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d2854a79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Type of dataset.patients : \n", + "Number of patients : 18,869\n", + "\n", + "Patient ID : 15709\n", + "Number of ECG records for this patient : 1\n", + "\n", + "Record #1 keys and values:\n", + " patient_id : 15709\n", + " ecg_id : 1\n", + " mat_path : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB/HR00001.mat\n", + " scp_codes : {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}\n", + " strat_fold : 3\n", + " age : 56.0\n", + " sex : 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ dataset.patients is built. No signals loaded yet — only metadata + file paths.\n" + ] + } + ], + "source": [ + "# ── STEP 5: Inspect the patients dictionary ──────────────────────────────────\n", + "\n", + "print(f\"Type of dataset.patients : {type(dataset.patients)}\")\n", + "print(f\"Number of patients : {len(dataset.patients):,}\\n\")\n", + "\n", + "# Look at the first patient\n", + "first_pid = list(dataset.patients.keys())[0]\n", + "first_recs = dataset.patients[first_pid]\n", + "\n", + "print(f\"Patient ID : {first_pid}\")\n", + "print(f\"Number of ECG records for this patient : {len(first_recs)}\\n\")\n", + "print(\"Record #1 keys and values:\")\n", + "for k, v in first_recs[0].items():\n", + " print(f\" {k:<14}: {v}\")\n", + "\n", + "# ── Distribution of ECGs per patient ─────────────────────────────────────────\n", + "ecg_counts = [len(v) for v in dataset.patients.values()]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "\n", + "# Left: histogram of ECGs per patient\n", + "axes[0].hist(ecg_counts, bins=range(1, max(ecg_counts) + 2),\n", + " color=\"#4a90d9\", edgecolor=\"white\", align=\"left\")\n", + "axes[0].set_title(\"ECG recordings per patient\", fontsize=12, fontweight=\"bold\")\n", + "axes[0].set_xlabel(\"# ECG recordings for one patient\")\n", + "axes[0].set_ylabel(\"# patients\")\n", + "axes[0].set_xticks(range(1, max(ecg_counts) + 1))\n", + "\n", + "# Right: strat_fold distribution\n", + "all_folds = [r[\"strat_fold\"] for recs in dataset.patients.values() for r in recs]\n", + "fold_counts = pd.Series(all_folds).value_counts().sort_index()\n", + "axes[1].bar(fold_counts.index, fold_counts.values, color=\"#e07b54\", edgecolor=\"white\")\n", + "axes[1].set_title(\"ECGs per stratification fold (1–10)\", fontsize=12, fontweight=\"bold\")\n", + "axes[1].set_xlabel(\"strat_fold\")\n", + "axes[1].set_ylabel(\"# ECG recordings\")\n", + "axes[1].set_xticks(range(1, 11))\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "print(\"\\n✅ dataset.patients is built. No signals loaded yet — only metadata + file paths.\")" + ] + }, + { + "cell_type": "markdown", + "id": "575df087", + "metadata": {}, + "source": [ + "---\n", + "## Section 6 — Apply the Superdiagnostic Task (`dataset.set_task(...)`)\n", + "\n", + "### What is a Task function?\n", + "\n", + "A **task function** is a plain Python function that:\n", + "\n", + "1. Receives **one patient's records** (the list from `dataset.patients[pid]`)\n", + "2. Loads the actual signal array from disk for each record\n", + "3. Applies a **sliding window** to break the 10-second recording into sub-windows\n", + "4. Converts `scp_codes` dict into a **multi-hot label vector**\n", + "5. Saves each window as a `.pkl` file (avoids re-loading on every epoch)\n", + "6. Returns a `List[Dict]` — one dict per window = one training sample\n", + "\n", + "### The 5 superdiagnostic classes\n", + "\n", + "PTB-XL's SCP codes are organized in a hierarchy. The **superdiagnostic** level has exactly 5 classes:\n", + "\n", + "| Index | Class | Meaning |\n", + "|---|---|---|\n", + "| 0 | `NORM` | Normal ECG |\n", + "| 1 | `CD` | Conduction Disturbance |\n", + "| 2 | `HYP` | Hypertrophy |\n", + "| 3 | `MI` | Myocardial Infarction |\n", + "| 4 | `STTC` | ST/T-change (ischemia signs) |\n", + "\n", + "A recording can have **multiple active classes simultaneously** — this is multi-label classification. \n", + "The label vector `[1, 0, 0, 1, 0]` means \"NORM and MI are both present.\"\n", + "\n", + "### Flow inside `set_task()`:\n", + "\n", + "```\n", + "dataset.patients\n", + " │\n", + " ╔═══════════════════════════════════════╗\n", + " ║ for each patient (18,885 patients): ║\n", + " ║ for each ECG record of that patient║\n", + " ║ 1. wfdb.rdsamp(wfdb_path) ║\n", + " ║ → signal (5000, 12) ║\n", + " ║ 2. scp_codes → 5-class label ║\n", + " ║ 3. Slide window (stride = 625) ║\n", + " ║ window 0: samples [0:1250] ║\n", + " ║ window 1: samples [625:1875] ║\n", + " ║ window 2: samples [1250:2500] ║\n", + " ║ window 3: samples [1875:3125] ║\n", + " ║ window 4: samples [2500:3750] ║\n", + " ║ window 5: samples [3125:4375] ║\n", + " ║ window 6: samples [3750:5000] ║\n", + " ║ 4. pickle.dump each window ║\n", + " ║ 5. append sample dict to list ║\n", + " ╚═══════════════════════════════════════╝\n", + " │\n", + " ▼\n", + "SampleDataset.samples = [\n", + " {patient_id:\"1\", ecg_id:\"1\", epoch_path:\"~/.cache/.../1-1-0.pkl\", label:[1,0,0,0,0]},\n", + " {patient_id:\"1\", ecg_id:\"1\", epoch_path:\"~/.cache/.../1-1-1.pkl\", label:[1,0,0,0,0]},\n", + " ... ← ~7 windows per ECG × 21,837 ECGs ≈ 152,859 total samples\n", + "]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7d06120b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\n", + "(uses pandarallel for parallel patient processing)\n", + "\n", + "INFO: Pandarallel will run on 10 workers.\n", + "INFO: Pandarallel will use standard multiprocessing data transfer (pipe) to transfer data between the main process and workers.\n", + "\n", + "PyHealth SampleSignalDataset built: 118,930 samples\n", + " input_info: {'signal': {'length': 1250, 'n_channels': 12}, 'label': {'type': , 'dim': 2}}\n", + "\n", + " Label prevalence (multi-hot, threshold=50%):\n", + " NORM 55.6% ████████████████\n", + " CD 21.4% ██████\n", + " HYP 13.2% ███\n", + " MI 22.7% ██████\n", + " STTC 3.9% █\n" + ] + } + ], + "source": [ + "# ── STEP 6: PyHealth Task Function — ptbxl_superdiagnostic_fn ────────────────\n", + "#\n", + "# A PyHealth task function:\n", + "# • Takes one patient's record list (from dataset.patients[pid])\n", + "# • Loads the ECG signal (or synthesises one)\n", + "# • Slices into 2.5-second windows with 50% overlap\n", + "# • Maps SCP codes → NORM / CD / HYP / MI / STTC labels\n", + "# • Stores each window as a .pkl file (epoch_path convention from PyHealth)\n", + "# • Returns a List[Dict], one dict per window\n", + "#\n", + "# Label format required by PyHealth SparcNet in \"multilabel\" mode:\n", + "# label = List[str], e.g. [\"NORM\"] or [\"CD\", \"STTC\"]\n", + "# (SparcNet.prepare_labels tokenises these → multi-hot tensor)\n", + "#\n", + "# Pickle format required by PyHealth SampleSignalDataset:\n", + "# {\"signal\": np.float32(12, T)} ← ONLY the signal array\n", + "# The \"label\" key stays in the outer sample dict (not in the pickle)\n", + "# so that SampleSignalDataset.__getitem__ leaves it untouched.\n", + "#\n", + "# Required keys in each sample dict (SampleSignalDataset contract):\n", + "# patient_id – str\n", + "# record_id – str ← required by SampleSignalDataset._index_record()\n", + "# epoch_path – str ← path to pkl with {\"signal\": ndarray}\n", + "# label – List[str]\n", + "\n", + "from scipy.io import loadmat as scipy_loadmat\n", + "\n", + "# ── SNOMED / SCP code → superdiagnostic class mapping ────────────────────────\n", + "# Source: Table 2 of Strodthoff et al. (2020) and PTB-XL scp_statements.csv\n", + "SNOMED_TO_SUPERDIAG = {\n", + " # --------------- NORM -----------------------------------------------\n", + " \"NORM\": \"NORM\",\n", + " # --------------- CD — Conduction Disturbance / Rhythm ---------------\n", + " \"LAFB\": \"CD\", \"LPFB\": \"CD\", \"IRBBB\": \"CD\", \"RBBB\": \"CD\",\n", + " \"LBBB\": \"CD\", \"IVCD\": \"CD\", \"IAVB\": \"CD\", \"I-AVB\": \"CD\",\n", + " \"WPW\": \"CD\", \"SVTAC\": \"CD\", \"PSVT\": \"CD\", \"AF\": \"CD\",\n", + " \"AFIB\": \"CD\", \"AVNRT\": \"CD\", \"AVRT\": \"CD\",\n", + " # --------------- HYP — Hypertrophy ----------------------------------\n", + " \"LVH\": \"HYP\", \"RVH\": \"HYP\",\n", + " \"LAO/LAE\": \"HYP\", \"RAO/RAE\":\"HYP\",\n", + " # --------------- MI — Myocardial Infarction -------------------------\n", + " \"AMI\": \"MI\", \"IMI\": \"MI\", \"LMI\": \"MI\", \"PMI\": \"MI\",\n", + " \"ISCAL\": \"MI\", \"ISCIN\": \"MI\", \"ISCAN\": \"MI\",\n", + " \"ISCLA\": \"MI\", \"ISC_\": \"MI\",\n", + " # --------------- STTC — ST/T-wave Change ----------------------------\n", + " \"STD_\": \"STTC\", \"STE_\": \"STTC\", \"NST_\": \"STTC\",\n", + " \"STTC\": \"STTC\", \"ANEUR\":\"STTC\",\n", + "}\n", + "\n", + "SUPERDIAG_CLASSES = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"] # canonical order\n", + "\n", + "\n", + "def ptbxl_superdiagnostic_fn(record_list: list,\n", + " epoch_sec: float = 2.5,\n", + " freq: int = 500,\n", + " scp_threshold: float = 50.0) -> list:\n", + " \"\"\"\n", + " PyHealth task function: converts one patient's ECG records into\n", + " a list of windowed samples for multi-label superdiagnostic classification.\n", + "\n", + " Args:\n", + " record_list : list of record dicts from PTBXLDataset.patients[pid]\n", + " epoch_sec : window length in seconds (2.5 s → 1250 samples @ 500 Hz)\n", + " freq : sampling rate (500 Hz)\n", + " scp_threshold : minimum SCP confidence (%) to count as positive\n", + "\n", + " Returns:\n", + " samples : List[Dict], each with keys:\n", + " patient_id – str\n", + " record_id – str (same as ecg_id; required by SampleSignalDataset)\n", + " ecg_id – str\n", + " epoch_path – str (path to pickle containing {\"signal\": ndarray})\n", + " label – List[str] e.g. [\"NORM\"], [\"CD\", \"STTC\"]\n", + " \"\"\"\n", + " samples = []\n", + " win_len = int(freq * epoch_sec) # 500 × 2.5 = 1250\n", + " stride = win_len // 2 # 50% overlap\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / \"windows\"\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " for visit in record_list:\n", + " pid = visit[\"patient_id\"]\n", + " ecg_id = visit[\"ecg_id\"]\n", + " mat_path = visit[\"mat_path\"]\n", + " scp_codes = visit[\"scp_codes\"]\n", + "\n", + " # ── 1. Build the label as a List[str] (required by SparcNet multilabel) ──\n", + " labels = list({\n", + " SNOMED_TO_SUPERDIAG[c]\n", + " for c, conf in scp_codes.items()\n", + " if c.upper() in SNOMED_TO_SUPERDIAG and float(conf) >= scp_threshold\n", + " })\n", + " if not labels:\n", + " continue # skip records with no mappable superdiagnostic code\n", + "\n", + " # ── 2. Load the ECG signal ──────────────────────────────────────────\n", + " if mat_path and Path(mat_path).exists():\n", + " mat = scipy_loadmat(mat_path)\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV (12, 5000)\n", + " else:\n", + " # Synthetic: 1-lead QRS spike pattern, replicated 12 times\n", + " t = np.linspace(0, freq * 10 / freq, freq * 10)\n", + " lead = 0.5 * np.sin(2 * np.pi * 1.2 * t) + np.random.randn(freq * 10) * 0.04\n", + " signal = np.tile(lead, (12, 1)).astype(np.float32) # (12, 5000)\n", + "\n", + " # ── 3. Sliding-window segmentation ─────────────────────────────────\n", + " n_windows = max(1, (signal.shape[1] - win_len) // stride + 1)\n", + " for idx in range(n_windows):\n", + " s = idx * stride\n", + " window = signal[:, s : s + win_len] # (12, 1250)\n", + " if window.shape[1] < win_len:\n", + " break # skip the last partial window\n", + "\n", + " # Save ONLY the signal in the pickle (label stays in outer dict)\n", + " pkl_path = str(cache_dir / f\"{pid}_{ecg_id}_{idx}.pkl\")\n", + " with open(pkl_path, \"wb\") as f:\n", + " pickle.dump({\"signal\": window}, f)\n", + "\n", + " samples.append({\n", + " \"patient_id\": pid,\n", + " \"record_id\": ecg_id, # ← required by SampleSignalDataset._index_record()\n", + " \"ecg_id\": ecg_id,\n", + " \"epoch_path\": pkl_path,\n", + " \"label\": labels, # List[str] — kept in outer dict\n", + " })\n", + " return samples\n", + "\n", + "\n", + "# ── Apply task via PyHealth's BaseSignalDataset.set_task() ────────────────────\n", + "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\")\n", + "print(\"(uses pandarallel for parallel patient processing)\\n\")\n", + "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", + "\n", + "# ── Patch input_info[\"label\"] for multilabel (label = List[str], dim=2) ──────\n", + "# PyHealth 1.1.6 hardcodes dim=0 for \"label\" in SampleSignalDataset._validate().\n", + "# We override it so that get_all_tokens(\"label\") correctly iterates the list.\n", + "sample_dataset.input_info[\"label\"] = {\"type\": str, \"dim\": 2}\n", + "\n", + "n = len(sample_dataset)\n", + "pos_rates = np.zeros(5)\n", + "for s in sample_dataset.samples:\n", + " for cls in s[\"label\"]:\n", + " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", + "pos_rates /= n\n", + "\n", + "print(f\"\\nPyHealth SampleSignalDataset built: {n:,} samples\")\n", + "print(f\" input_info: {sample_dataset.input_info}\")\n", + "print(f\"\\n Label prevalence (multi-hot, threshold={50}%):\")\n", + "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", + " bar = \"█\" * int(rate * 30)\n", + " print(f\" {cls:<6} {rate:.1%} {bar}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "f775ce31", + "metadata": {}, + "source": [ + "---\n", + "## Section 7 — Visualize a Sample Window and its Multi-hot Label" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2b1a0802", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " signal shape : (12, 1250) (12 leads × 1250 samples @ 500 Hz = 2.5 s)\n", + " label : ['NORM'] → multi-hot: [1.0, 0.0, 0.0, 0.0, 0.0]\n" + ] + } + ], + "source": [ + "# ── STEP 7: Visualize a saved window from disk ────────────────────────────────\n", + "#\n", + "# The pickle files written by ptbxl_superdiagnostic_fn contain ONLY:\n", + "# {\"signal\": np.float32(12, 1250)}\n", + "# The \"label\" (List[str]) lives in the outer sample dict — NOT in the pickle.\n", + "# We convert the List[str] label → multi-hot float array for the bar chart.\n", + "\n", + "def visualize_sample(sample: dict):\n", + " \"\"\"Plot the 12-lead ECG window and the multi-hot label bar chart.\"\"\"\n", + " # Load signal from pickle\n", + " with open(sample[\"epoch_path\"], \"rb\") as f:\n", + " data = pickle.load(f)\n", + "\n", + " signal = data[\"signal\"] # np.float32 (12, 1250)\n", + " label_list = sample[\"label\"] # List[str] e.g. [\"NORM\"] or [\"CD\",\"MI\"]\n", + "\n", + " # Convert List[str] → multi-hot float array for plotting\n", + " label_vec = [1.0 if cls in label_list else 0.0 for cls in SUPERDIAG_CLASSES]\n", + "\n", + " fig = plt.figure(figsize=(15, 9))\n", + " gs = gridspec.GridSpec(2, 1, figure=fig, height_ratios=[4, 1], hspace=0.4)\n", + "\n", + " # ── Top panel: 12-lead ECG ────────────────────────────────────────────────\n", + " gs_top = gridspec.GridSpecFromSubplotSpec(6, 2, subplot_spec=gs[0],\n", + " hspace=0.05, wspace=0.3)\n", + " lead_names = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", + " t_axis = np.arange(signal.shape[1]) / 500.0 # seconds\n", + "\n", + " for i in range(12):\n", + " row, col = divmod(i, 2)\n", + " ax = fig.add_subplot(gs_top[row, col])\n", + " ax.plot(t_axis, signal[i], linewidth=0.8, color=\"#1f77b4\")\n", + " ax.set_ylabel(lead_names[i], fontsize=8, rotation=0, labelpad=18)\n", + " ax.set_yticks([])\n", + " if row < 5:\n", + " ax.set_xticks([])\n", + " else:\n", + " ax.set_xlabel(\"Time (s)\", fontsize=8)\n", + "\n", + " patient_scp = dataset.patients[sample[\"patient_id\"]][0][\"scp_codes\"]\n", + " fig.text(0.5, 0.96,\n", + " f\"2.5-second ECG window — patient {sample['patient_id']}, \"\n", + " f\"ecg_id {sample['ecg_id']} | shape: {signal.shape}\",\n", + " ha=\"center\", fontsize=11, fontweight=\"bold\")\n", + "\n", + " # ── Bottom panel: multi-hot label bar chart ───────────────────────────────\n", + " ax_label = fig.add_subplot(gs[1])\n", + " colors = [\"#2ecc71\" if v == 1.0 else \"#e74c3c\" for v in label_vec]\n", + " bars = ax_label.bar(SUPERDIAG_CLASSES, label_vec, color=colors,\n", + " edgecolor=\"white\", width=0.6)\n", + "\n", + " for bar, val in zip(bars, label_vec):\n", + " status = \"✓ ACTIVE\" if val == 1.0 else \"✗ absent\"\n", + " ax_label.text(bar.get_x() + bar.get_width()/2, val + 0.03,\n", + " status, ha=\"center\", va=\"bottom\", fontsize=9,\n", + " color=\"#2ecc71\" if val == 1.0 else \"#aaaaaa\")\n", + "\n", + " ax_label.set_ylim(0, 1.5)\n", + " ax_label.set_ylabel(\"Label value\\n(0 or 1)\", fontsize=9)\n", + " ax_label.set_title(\n", + " f\"Multi-hot label: {label_list} | original SCP codes: {list(patient_scp.keys())}\",\n", + " fontsize=9)\n", + " ax_label.set_yticks([0, 1])\n", + " ax_label.legend(handles=[\n", + " mpatches.Patch(color=\"#2ecc71\", label=\"Active class (label=1)\"),\n", + " mpatches.Patch(color=\"#e74c3c\", label=\"Inactive class (label=0)\"),\n", + " ], loc=\"upper right\", fontsize=8)\n", + "\n", + " plt.show()\n", + " print(f\"\\n signal shape : {signal.shape} (12 leads × 1250 samples @ 500 Hz = 2.5 s)\")\n", + " print(f\" label : {label_list} → multi-hot: {label_vec}\")\n", + "\n", + "\n", + "# Pick the first sample and visualize\n", + "visualize_sample(sample_dataset.samples[0])\n" + ] + }, + { + "cell_type": "markdown", + "id": "4473b9e4", + "metadata": {}, + "source": [ + "---\n", + "## Section 8 — Split Dataset by Patient (Train / Val / Test)\n", + "\n", + "### Why split by Patient, not by Sample?\n", + "\n", + "If you split randomly by sample, windows from the **same patient** can appear in both \n", + "train and test. The model memorizes the patient's signal rather than learning the disease. \n", + "This is **data leakage** — test accuracy looks high but won't generalize.\n", + "\n", + "**The correct approach:** split the `patients` dict first, then gather all samples from each group.\n", + "\n", + "```\n", + "All 18,885 patients\n", + " ├── Train patients (80%) → all their windows → Train split\n", + " ├── Val patients (10%) → all their windows → Val split\n", + " └── Test patients (10%) → all their windows → Test split\n", + "\n", + "Guarantee: ∀ p ∈ train_pids: p ∉ val_pids AND p ∉ test_pids\n", + "```\n", + "\n", + "The original paper uses **stratified folds 1–10** (fold 9 for val, fold 10 for test). \n", + "PyHealth's `split_by_patient()` uses random patient-level assignment instead (same principle)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "036f2200", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PyHealth patient-level split (seed=42):\n", + " Train : 95,242 samples (80.1%)\n", + " Val : 12,005 samples (10.1%)\n", + " Test : 11,683 samples (9.8%)\n", + "\n", + " Batches / epoch : 2977\n", + " Batch size : 32\n", + "\n", + "Sample batch keys : ['patient_id', 'record_id', 'ecg_id', 'label', 'signal']\n", + " signal : list × 32 shapes e.g. (12, 1250) (12 leads × 1250 samples)\n", + " label first item : ['NORM'] (List[str])\n", + "\n", + "✅ Zero patient overlap across splits — no data leakage.\n", + " Train patients : 12,184 | Val : 1,523 | Test : 1,524\n" + ] + } + ], + "source": [ + "# ── STEP 8: Patient-level split + PyHealth DataLoaders ───────────────────────\n", + "#\n", + "# Why patient-level split?\n", + "# Splitting by sample risks putting windows from the same recording in both\n", + "# train and test — the model sees the same patient twice → inflated metrics.\n", + "# split_by_patient() assigns ALL windows from one patient to a single split.\n", + "#\n", + "# PyHealth API used:\n", + "# split_by_patient(dataset, ratios, seed)\n", + "# • returns three torch.utils.data.Subset objects (train / val / test)\n", + "# • internally indexes by patient_to_index built in SampleSignalDataset\n", + "#\n", + "# get_dataloader(dataset, batch_size, shuffle)\n", + "# • wraps Subset in torch DataLoader with collate_fn_dict\n", + "# • collate_fn_dict returns {key: list_of_values} — SparcNet handles\n", + "# the list-of-arrays → tensor conversion internally in forward()\n", + "\n", + "train_ds, val_ds, test_ds = split_by_patient(\n", + " dataset = sample_dataset,\n", + " ratios = [0.8, 0.1, 0.1],\n", + " seed = 42,\n", + ")\n", + "\n", + "BATCH_SIZE = 32\n", + "train_loader = get_dataloader(train_ds, batch_size=BATCH_SIZE, shuffle=True)\n", + "val_loader = get_dataloader(val_ds, batch_size=BATCH_SIZE, shuffle=False)\n", + "test_loader = get_dataloader(test_ds, batch_size=BATCH_SIZE, shuffle=False)\n", + "\n", + "# ── Verify split sizes ────────────────────────────────────────────────────────\n", + "print(\"PyHealth patient-level split (seed=42):\")\n", + "print(f\" Train : {len(train_ds):>6,} samples ({len(train_ds)/len(sample_dataset):.1%})\")\n", + "print(f\" Val : {len(val_ds):>6,} samples ({len(val_ds)/len(sample_dataset):.1%})\")\n", + "print(f\" Test : {len(test_ds):>6,} samples ({len(test_ds)/len(sample_dataset):.1%})\")\n", + "print(f\"\\n Batches / epoch : {len(train_loader)}\")\n", + "print(f\" Batch size : {BATCH_SIZE}\")\n", + "\n", + "# ── Peek at one batch to confirm shapes ──────────────────────────────────────\n", + "batch = next(iter(train_loader))\n", + "print(f\"\\nSample batch keys : {list(batch.keys())}\")\n", + "print(f\" signal : list × {len(batch['signal'])} \"\n", + " f\"shapes e.g. {np.array(batch['signal'][0]).shape} (12 leads × 1250 samples)\")\n", + "print(f\" label first item : {batch['label'][0]} (List[str])\")\n", + "\n", + "# ── Leak check : no patient in two splits ─────────────────────────────────────\n", + "def patient_ids(subset):\n", + " ds = subset.dataset\n", + " return {ds.samples[i][\"patient_id\"] for i in subset.indices}\n", + "\n", + "train_pts = patient_ids(train_ds)\n", + "val_pts = patient_ids(val_ds)\n", + "test_pts = patient_ids(test_ds)\n", + "\n", + "assert len(train_pts & val_pts) == 0, \"LEAKAGE: train ∩ val!\"\n", + "assert len(train_pts & test_pts) == 0, \"LEAKAGE: train ∩ test!\"\n", + "assert len(val_pts & test_pts) == 0, \"LEAKAGE: val ∩ test!\"\n", + "print(f\"\\n✅ Zero patient overlap across splits — no data leakage.\")\n", + "print(f\" Train patients : {len(train_pts):,} \"\n", + " f\"| Val : {len(val_pts):,} | Test : {len(test_pts):,}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc3ef579", + "metadata": {}, + "source": [ + "---\n", + "## Section 9 — Define and Initialize the DNN Model\n", + "\n", + "### Architecture choices from the paper\n", + "\n", + "The benchmark tests **9 architectures**, all adapted from 2D image models to 1D ECG:\n", + "\n", + "| Model | Adapted from | Key 1D change |\n", + "|---|---|---|\n", + "| **ResNet1d** | ResNet-18/34 | `Conv2d → Conv1d`, kernel `7×7→7`, maxpool `3×3→3` |\n", + "| **BiLSTM** | LSTM stacks | Bidirectional, hidden=256, 3 layers |\n", + "| **Transformer** | ViT / BERT | Patch size = 250 samples from each lead |\n", + "| EfficientNet1d | EfficientNet | MBConv blocks with 1D depthwise-separable conv |\n", + "| MobileNetV3 1d | MobileNet-V3 | Bottleneck inverted residual, SE attention |\n", + "| NFNet1d | NF-ResNet | Normalizer-free residual with scaled skip |\n", + "| SENet1d | SE-ResNet | Squeeze-excitation channel attention blocks |\n", + "| SqueezeNet1d | SqueezeNet | Fire modules with 1×1 + 3×1 filters |\n", + "| LambdaNet1d | LambdaNet | Lambda layer for long-range content interaction |\n", + "\n", + "All share the same **head module** (the classifier):\n", + "```\n", + "backbone_out (256-dim)\n", + " → Linear(256 → 128)\n", + " → ReLU\n", + " → BatchNorm1d(128)\n", + " → Dropout(p=0.25)\n", + " → Linear(128 → num_classes=5)\n", + " → (BCEWithLogitsLoss applies sigmoid internally)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "90b71e50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Input data statistics ===\n", + "n_channels: 12\n", + "length: 1250\n", + "Model A — PyHealth SparcNet\n", + " Trainable params : 1,103,224\n", + " Input shape : (B, 12, 1250) — 12 leads × 1250 samples per window\n", + " Output shape : (B, 5) — 5 superdiagnostic class scores\n", + "\n", + "Model B — BiLSTMECG (custom pyhealth.models.BaseModel subclass)\n", + " Trainable params : 937,221\n", + " Architecture : BiLSTM(12→128, ×3 layers) → FC(256→5)\n", + "\n", + "Forward pass smoke test (batch_size=32):\n", + " SparcNet logit: (32, 5) loss: 0.6875\n", + " BiLSTMECG logit: (32, 5) loss: 0.6998\n", + "\n", + "✅ Both models produce standard PyHealth output dicts.\n" + ] + } + ], + "source": [ + "# ── STEP 9: PyHealth Models ───────────────────────────────────────────────────\n", + "#\n", + "# Model A — SparcNet (from pyhealth.models)\n", + "# ─────────────────────────────────────────\n", + "# SparcNet is PyHealth's built-in DenseNet-based 1-D signal classifier.\n", + "# • Architecture: 1D DenseNet (Dense blocks + Transition layers)\n", + "# adapted from Jin Jing et al., Neurology 2023\n", + "# • Input: (batch, 12 leads, 1250 samples) → batch of ECG windows\n", + "# • Output dict: {\"loss\": scalar, \"y_prob\": (B,K), \"y_true\": (B,K), ...}\n", + "# • Constructed from SampleSignalDataset so it auto-detects n_channels & length\n", + "# • mode=\"multilabel\" → BCEWithLogitsLoss + sigmoid output\n", + "#\n", + "# Model B — BiLSTMECG (custom PyHealth BaseModel subclass)\n", + "# ────────────────────────────────────────────────────────\n", + "# A bidirectional-LSTM classifier that extends pyhealth.models.BaseModel.\n", + "# • By extending BaseModel it inherits prepare_labels, prepare_y_prob,\n", + "# get_loss_function, and Trainer compatibility — no boilerplate needed.\n", + "# • Input: same shape as SparcNet\n", + "# • Output: same dict format {\"loss\", \"y_prob\", \"y_true\", \"logit\"}\n", + "#\n", + "# Both models are interchangeable with PyHealth's Trainer and evaluation APIs.\n", + "\n", + "import math\n", + "from collections import OrderedDict\n", + "\n", + "# ── Model A: SparcNet ─────────────────────────────────────────────────────────\n", + "sparcnet = SparcNet(\n", + " dataset = sample_dataset, # SampleSignalDataset (for input_info)\n", + " feature_keys = [\"signal\"], # key in the sample dict\n", + " label_key = \"label\", # key holding the List[str] labels\n", + " mode = \"multilabel\", # BCEWithLogitsLoss + sigmoid\n", + ")\n", + "\n", + "print(\"Model A — PyHealth SparcNet\")\n", + "n_params_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", + "print(f\" Trainable params : {n_params_sparcnet:,}\")\n", + "print(f\" Input shape : (B, 12, 1250) — 12 leads × 1250 samples per window\")\n", + "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) — 5 superdiagnostic class scores\")\n", + "\n", + "\n", + "# ── Model B: BiLSTMECG — custom PyHealth BaseModel ───────────────────────────\n", + "\n", + "class BiLSTMECG(BaseModel):\n", + " \"\"\"\n", + " Bidirectional LSTM ECG classifier extending pyhealth.models.BaseModel.\n", + "\n", + " By inheriting BaseModel we get for free:\n", + " • prepare_labels() — str labels → multi-hot tensor\n", + " • prepare_y_prob() — logits → sigmoid probabilities \n", + " • get_loss_function()— BCEWithLogitsLoss for multilabel\n", + " • Trainer compatibility (forward must return the standard dict)\n", + "\n", + " Architecture:\n", + " Input (B, 12, T) → permute → BiLSTM(12→256) → last state\n", + " → Linear(256→K) → sigmoid (applied by prepare_y_prob)\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dataset,\n", + " feature_keys,\n", + " label_key,\n", + " mode,\n", + " hidden_size: int = 128,\n", + " n_layers: int = 3,\n", + " dropout: float = 0.2,\n", + " **kwargs,\n", + " ):\n", + " super().__init__(\n", + " dataset = dataset,\n", + " feature_keys = feature_keys,\n", + " label_key = label_key,\n", + " mode = mode,\n", + " )\n", + " # Read input dimensions from SampleSignalDataset.input_info\n", + " sig_info = self.dataset.input_info[\"signal\"]\n", + " in_channels = sig_info[\"n_channels\"]\n", + "\n", + " # Build tokenizer (BaseModel.get_label_tokenizer needs input_info dim=2)\n", + " self.label_tokenizer = self.get_label_tokenizer()\n", + " output_size = self.get_output_size(self.label_tokenizer)\n", + "\n", + " self.lstm = nn.LSTM(\n", + " input_size = in_channels,\n", + " hidden_size = hidden_size,\n", + " num_layers = n_layers,\n", + " bidirectional=True,\n", + " batch_first =True,\n", + " dropout = dropout if n_layers > 1 else 0.0,\n", + " )\n", + " self.fc = nn.Linear(hidden_size * 2, output_size)\n", + "\n", + " def forward(self, **kwargs) -> dict:\n", + " \"\"\"\n", + " Forward pass.\n", + "\n", + " Expects kwargs[\"signal\"] = List[np.ndarray(12, T)] (from collate_fn_dict).\n", + " Returns the standard PyHealth dict: {loss, y_prob, y_true, logit}.\n", + " \"\"\"\n", + " # Stack list of numpy arrays → tensor (B, 12, T)\n", + " x = torch.tensor(np.array(kwargs[self.feature_keys[0]]),\n", + " device=self.device).float()\n", + " # LSTM expects (B, T, C) — permute\n", + " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", + " logits = self.fc(out[:, -1, :]) # (B, K) — last time step\n", + "\n", + " # PyHealth BaseModel helpers\n", + " y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer)\n", + " loss = self.get_loss_function()(logits, y_true)\n", + " y_prob = self.prepare_y_prob(logits)\n", + "\n", + " return {\"loss\": loss, \"y_prob\": y_prob, \"y_true\": y_true, \"logit\": logits}\n", + "\n", + "\n", + "bilstm = BiLSTMECG(\n", + " dataset = sample_dataset,\n", + " feature_keys = [\"signal\"],\n", + " label_key = \"label\",\n", + " mode = \"multilabel\",\n", + " hidden_size = 128,\n", + " n_layers = 3,\n", + ")\n", + "\n", + "print(\"\\nModel B — BiLSTMECG (custom pyhealth.models.BaseModel subclass)\")\n", + "n_params_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", + "print(f\" Trainable params : {n_params_bilstm:,}\")\n", + "print(f\" Architecture : BiLSTM(12→128, ×3 layers) → FC(256→5)\")\n", + "\n", + "# ── Smoke test: one forward pass ─────────────────────────────────────────────\n", + "with torch.no_grad():\n", + " test_batch = next(iter(train_loader))\n", + " out_s = sparcnet(**test_batch)\n", + " out_b = bilstm(**test_batch)\n", + "\n", + "print(f\"\\nForward pass smoke test (batch_size={BATCH_SIZE}):\")\n", + "print(f\" SparcNet logit: {tuple(out_s['logit'].shape)} loss: {out_s['loss'].item():.4f}\")\n", + "print(f\" BiLSTMECG logit: {tuple(out_b['logit'].shape)} loss: {out_b['loss'].item():.4f}\")\n", + "print(f\"\\n✅ Both models produce standard PyHealth output dicts.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3fa22098", + "metadata": {}, + "source": [ + "---\n", + "## Section 10 — Train the Model with the PyHealth-style Trainer\n", + "\n", + "### What the Trainer does\n", + "\n", + "```\n", + "Trainer.__init__(model, optimizer, loss_fn)\n", + " │\n", + " ▼\n", + "trainer.train(train_samples, val_samples, n_epochs=250)\n", + " │\n", + " ├── for each epoch:\n", + " │ ├── for each mini-batch (B=64):\n", + " │ │ ├── load signal from sample[\"epoch_path\"] (pkl file)\n", + " │ │ ├── forward pass → logits (B, 5)\n", + " │ │ ├── BCEWithLogitsLoss(logits, multi-hot labels)\n", + " │ │ ├── loss.backward()\n", + " │ │ └── optimizer.step()\n", + " │ │\n", + " │ └── every 5 epochs: evaluate on val_samples\n", + " │ → compute macro ROC-AUC\n", + " │ → EarlyStopper checks if improved (patience=5)\n", + " │\n", + " └── restore best checkpoint (highest val ROC-AUC)\n", + "```\n", + "\n", + "**Loss function:** `BCEWithLogitsLoss` — binary cross-entropy with built-in sigmoid, \n", + "applied **independently** to each of the 5 output neurons. \n", + "This is correct for multi-label because a recording can activate multiple classes simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "156a0428", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " Training SparcNet with PyHealth Trainer\n", + "============================================================\n", + "SparcNet(\n", + " (encoder): Sequential(\n", + " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", + " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu0): ELU(alpha=1.0)\n", + " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (denseblock1): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition1): TransitionLayer(\n", + " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock2): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition2): TransitionLayer(\n", + " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock3): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition3): TransitionLayer(\n", + " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock4): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition4): TransitionLayer(\n", + " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock5): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition5): TransitionLayer(\n", + " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock6): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition6): TransitionLayer(\n", + " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock7): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition7): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock8): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition8): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " )\n", + " (fc): Linear(in_features=63, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 5\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 5: 100%|██████████| 2977/2977 [26:12<00:00, 1.89it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-2977 ---\n", + "loss: 0.2943\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [02:27<00:00, 2.55it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-2977 ---\n", + "roc_auc_macro: 0.8829\n", + "f1_macro: 0.5913\n", + "loss: 0.2975\n", + "New best roc_auc_macro score (0.8829) at epoch-0, step-2977\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 5: 100%|██████████| 2977/2977 [26:39<00:00, 1.86it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-5954 ---\n", + "loss: 0.2597\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [02:25<00:00, 2.59it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-5954 ---\n", + "roc_auc_macro: 0.9036\n", + "f1_macro: 0.5977\n", + "loss: 0.2642\n", + "New best roc_auc_macro score (0.9036) at epoch-1, step-5954\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 5: 100%|██████████| 2977/2977 [1:35:10<00:00, 1.92s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-8931 ---\n", + "loss: 0.2477\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [02:21<00:00, 2.66it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-8931 ---\n", + "roc_auc_macro: 0.9076\n", + "f1_macro: 0.6094\n", + "loss: 0.2624\n", + "New best roc_auc_macro score (0.9076) at epoch-2, step-8931\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 3 / 5: 100%|██████████| 2977/2977 [26:02<00:00, 1.91it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-3, step-11908 ---\n", + "loss: 0.2398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [02:22<00:00, 2.63it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-3, step-11908 ---\n", + "roc_auc_macro: 0.9130\n", + "f1_macro: 0.5941\n", + "loss: 0.2596\n", + "New best roc_auc_macro score (0.9130) at epoch-3, step-11908\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 4 / 5: 100%|██████████| 2977/2977 [1:05:26<00:00, 1.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-4, step-14885 ---\n", + "loss: 0.2349\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [02:26<00:00, 2.57it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-4, step-14885 ---\n", + "roc_auc_macro: 0.9180\n", + "f1_macro: 0.6307\n", + "loss: 0.2442\n", + "New best roc_auc_macro score (0.9180) at epoch-4, step-14885\n", + "Loaded best model\n", + "\n", + "SparcNet training complete.\n", + "Best checkpoint: ./output/ptbxl/sparcnet_superdiag_5class/best.ckpt\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# ── STEP 10: Train SparcNet with PyHealth's Trainer ──────────────────────────\n", + "#\n", + "# pyhealth.trainer.Trainer encapsulates the full training loop:\n", + "# • AdamW optimiser with configurable lr & weight decay\n", + "# • Epoch loop with validation every N epochs\n", + "# • Early stopping: stops when monitor metric has not improved for `patience` epochs\n", + "# • Checkpoint saving: saves best.ckpt and last.ckpt to output_path/exp_name/\n", + "# • Automatic evaluation using multilabel_metrics_fn at every validation step\n", + "#\n", + "# Trainer.train() signature (key parameters):\n", + "# train_dataloader – DataLoader for training\n", + "# val_dataloader – DataLoader for validation\n", + "# epochs – total training epochs (paper uses 50–100; 5 here for demo)\n", + "# optimizer_params – dict passed to Adam, e.g. {\"lr\": 1e-3}\n", + "# monitor – metric name to watch (e.g. \"roc_auc_macro\")\n", + "# monitor_criterion – \"max\" (higher is better) or \"min\"\n", + "# patience – early stopping patience (in evaluation steps)\n", + "# load_best_model_at_last – restore best checkpoint after training\n", + "\n", + "print(\"=\" * 60)\n", + "print(\" Training SparcNet with PyHealth Trainer\")\n", + "print(\"=\" * 60)\n", + "\n", + "trainer_sparcnet = Trainer(\n", + " model = sparcnet,\n", + " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", + " enable_logging = True,\n", + " output_path = \"./output/ptbxl\",\n", + " exp_name = \"sparcnet_superdiag_5class\",\n", + ")\n", + "\n", + "trainer_sparcnet.train(\n", + " train_dataloader = train_loader,\n", + " val_dataloader = val_loader,\n", + " epochs = 5, # increase to 20+ for paper results\n", + " optimizer_params = {\"lr\": 1e-3},\n", + " weight_decay = 1e-4,\n", + " monitor = \"roc_auc_macro\",\n", + " monitor_criterion = \"max\",\n", + " load_best_model_at_last = True,\n", + ")\n", + "\n", + "print(\"\\nSparcNet training complete.\")\n", + "print(\"Best checkpoint: ./output/ptbxl/sparcnet_superdiag_5class/best.ckpt\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "fabe80f0", + "metadata": {}, + "source": [ + "---\n", + "## Section 11 — Evaluate: ROC-AUC macro and F1 macro\n", + "\n", + "### Why these two metrics?\n", + "\n", + "| Metric | What it measures | Used by |\n", + "|---|---|---|\n", + "| **ROC-AUC macro** | Ranking quality — how well the model orders positives above negatives, averaged across classes. Threshold-independent. | Primary metric in the original paper |\n", + "| **F1 macro** | Precision-recall balance at 0.5 threshold, averaged across classes. Penalizes false negatives equally. | Standard complement to AUC |\n", + "\n", + "For **multi-label**: both metrics are computed **per class** then macro-averaged (unweighted mean). \n", + "A class with only 5 positives counts equally to a class with 5,000 positives — macro averaging is strict." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "85ff3ccc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " SparcNet — Test Set Evaluation (PyHealth Trainer.evaluate)\n", + "============================================================\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluation: 100%|██████████| 366/366 [02:20<00:00, 2.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Test ROC-AUC (macro) : 0.9278\n", + " Test F1 (macro) : 0.6316\n", + " Test Loss : 0.2232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Evaluation: 100%|██████████| 366/366 [02:21<00:00, 2.58it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Per-class ROC-AUC:\n", + " NORM 0.9210 ██████████████████\n", + " CD 0.9151 ██████████████████\n", + " HYP 0.9464 ██████████████████\n", + " MI 0.9606 ███████████████████\n", + " STTC 0.8959 █████████████████\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ── STEP 11: Evaluate SparcNet on the held-out test set ──────────────────────\n", + "#\n", + "# Trainer.evaluate(dataloader):\n", + "# 1. Runs inference in no_grad mode over every batch\n", + "# 2. Collects y_true (multi-hot from prepare_labels) and y_prob (sigmoid)\n", + "# 3. Calls multilabel_metrics_fn(y_true, y_prob) to compute:\n", + "# roc_auc_macro — primary metric used in the DLH paper\n", + "# f1_macro — secondary metric\n", + "# loss — mean BCE loss on test set\n", + "\n", + "print(\"=\" * 60)\n", + "print(\" SparcNet — Test Set Evaluation (PyHealth Trainer.evaluate)\")\n", + "print(\"=\" * 60)\n", + "\n", + "sparcnet_scores = trainer_sparcnet.evaluate(test_loader)\n", + "\n", + "print(f\"\\n Test ROC-AUC (macro) : {sparcnet_scores['roc_auc_macro']:.4f}\")\n", + "print(f\" Test F1 (macro) : {sparcnet_scores['f1_macro']:.4f}\")\n", + "print(f\" Test Loss : {sparcnet_scores['loss']:.4f}\")\n", + "\n", + "# ── Per-class breakdown using y_prob and y_true from inference ────────────────\n", + "y_true_all, y_prob_all, _ = trainer_sparcnet.inference(test_loader)\n", + "# y_true_all, y_prob_all are numpy (N, K) arrays\n", + "\n", + "# Per-class AUC\n", + "per_class_auc = {}\n", + "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", + " col = y_true_all[:, k]\n", + " if col.sum() > 0 and (1 - col).sum() > 0:\n", + " per_class_auc[cls] = roc_auc_score(col, y_prob_all[:, k])\n", + " else:\n", + " per_class_auc[cls] = float(\"nan\")\n", + "\n", + "print(f\"\\n Per-class ROC-AUC:\")\n", + "for cls, auc in per_class_auc.items():\n", + " bar = \"█\" * int((auc if not np.isnan(auc) else 0) * 20)\n", + " tag = f\"{auc:.4f}\" if not np.isnan(auc) else \" N/A (class absent in test)\"\n", + " print(f\" {cls:<6} {tag} {bar}\")\n", + "\n", + "# ── ROC curves (all classes) ──────────────────────────────────────────────────\n", + "from sklearn.metrics import roc_curve\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "colors = [\"#e74c3c\", \"#3498db\", \"#2ecc71\", \"#f39c12\", \"#9b59b6\"]\n", + "\n", + "for k, (cls, color) in enumerate(zip(SUPERDIAG_CLASSES, colors)):\n", + " col = y_true_all[:, k]\n", + " if col.sum() > 0 and (1-col).sum() > 0:\n", + " fpr, tpr, _ = roc_curve(col, y_prob_all[:, k])\n", + " auc = per_class_auc[cls]\n", + " axes[0].plot(fpr, tpr, color=color, lw=1.8,\n", + " label=f\"{cls} (AUC={auc:.3f})\")\n", + "\n", + "axes[0].plot([0,1],[0,1],\"k--\", lw=1, alpha=0.5, label=\"Random\")\n", + "axes[0].set_title(\"SparcNet — Per-class ROC Curves\", fontweight=\"bold\")\n", + "axes[0].set_xlabel(\"False Positive Rate\")\n", + "axes[0].set_ylabel(\"True Positive Rate\")\n", + "axes[0].legend(fontsize=9)\n", + "\n", + "# Per-class F1 bar chart\n", + "per_class_f1 = {}\n", + "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", + " col = y_true_all[:, k]\n", + " pred = (y_prob_all[:, k] >= 0.5).astype(int)\n", + " per_class_f1[cls] = f1_score(col, pred, zero_division=0)\n", + "\n", + "axes[1].bar(SUPERDIAG_CLASSES, [per_class_f1[c] for c in SUPERDIAG_CLASSES],\n", + " color=colors, edgecolor=\"white\")\n", + "for i, (cls, score) in enumerate(per_class_f1.items()):\n", + " axes[1].text(i, score + 0.01, f\"{score:.3f}\", ha=\"center\", fontsize=9)\n", + "axes[1].set_ylim(0, 1.15)\n", + "axes[1].set_title(\"SparcNet — Per-class F1 Score\", fontweight=\"bold\")\n", + "axes[1].set_ylabel(\"F1 Score\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "8b2bfa0c", + "metadata": {}, + "source": [ + "---\n", + "## Section 12 — Ablation Study: Compare ResNet1d vs BiLSTM\n", + "\n", + "The original paper benchmarks **9 architectures**. The core scientific contribution of your \n", + "CS-598 project is the **ablation study**: running the same pipeline with at least 2 architectures \n", + "and comparing them. This is what turns \"I ran some experiments\" into a reproducible scientific claim.\n", + "\n", + "### Ablation study design\n", + "\n", + "| Setting | Value |\n", + "|---|---|\n", + "| Dataset | PTB-XL superdiagnostic (5 classes, multi-label) |\n", + "| Architectures compared | ResNet1d vs BiLSTM (and optionally Transformer) |\n", + "| Primary metric | Macro ROC-AUC (threshold-independent) |\n", + "| Secondary metric | Macro F1 @ threshold=0.5 |\n", + "| Random seeds | 5 seeds → mean ± std |\n", + "| Statistical test | Welch's t-test + Benjamini-Hochberg correction |\n", + "| Window size | 2.5 seconds (1250 samples @ 500 Hz) |\n", + "| Overlap | 50% (stride = 625) |\n", + "\n", + "This section runs a **single-seed comparison** for demo speed. Replace with 5-seed loops for the paper." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8a558a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " Training BiLSTMECG (custom BaseModel) with PyHealth Trainer\n", + "============================================================\n", + "BiLSTMECG(\n", + " (lstm): LSTM(12, 128, num_layers=3, batch_first=True, dropout=0.2, bidirectional=True)\n", + " (fc): Linear(in_features=256, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 5\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 5: 17%|█▋ | 495/2977 [10:18<51:56, 1.26s/it] " + ] + } + ], + "source": [ + "# ── STEP 12a: Train BiLSTMECG with PyHealth Trainer (ablation) ───────────────\n", + "#\n", + "# Same Trainer API, same dataloaders, different model — this is the ablation.\n", + "# Both models see identical data splits and evaluation protocol.\n", + "\n", + "print(\"=\" * 60)\n", + "print(\" Training BiLSTMECG (custom BaseModel) with PyHealth Trainer\")\n", + "print(\"=\" * 60)\n", + "\n", + "trainer_bilstm = Trainer(\n", + " model = bilstm,\n", + " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", + " enable_logging = True,\n", + " output_path = \"./output/ptbxl\",\n", + " exp_name = \"bilstm_superdiag_5class\",\n", + ")\n", + "\n", + "trainer_bilstm.train(\n", + " train_dataloader = train_loader,\n", + " val_dataloader = val_loader,\n", + " epochs = 5,\n", + " optimizer_params = {\"lr\": 1e-3},\n", + " weight_decay = 1e-4,\n", + " monitor = \"roc_auc_macro\",\n", + " monitor_criterion = \"max\",\n", + " load_best_model_at_last = True,\n", + ")\n", + "\n", + "bilstm_scores = trainer_bilstm.evaluate(test_loader)\n", + "print(f\"\\n BiLSTMECG test ROC-AUC (macro) : {bilstm_scores['roc_auc_macro']:.4f}\")\n", + "print(f\" BiLSTMECG test F1 (macro) : {bilstm_scores['f1_macro']:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae628529", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABv0AAAHvCAYAAAB36RObAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdB3hUVfrH8TeV0Am9CqgUG4igiL2g2LtiBbH3wrp2Uay7qyIqKPZe174WXBurKDYQOyLSQm+hk5Ay/+d3+N/hzmQmmYQkM5P5fp5nYMqdO/fcuXPvyXnPeU9aIBAIGAAAAAAAAAAAAICklR7vDQAAAAAAAAAAAACwZQj6AQAAAAAAAAAAAEmOoB8AAAAAAAAAAACQ5Aj6AQAAAAAAAAAAAEmOoB8AAAAAAAAAAACQ5Aj6AQAAAAAAAAAAAEmOoB8AAAAAAAAAAACQ5Aj6AQAAAAAAAAAAAEmOoB8AAAAAAAAAAACQ5Aj6AQCAlHTmmWdaWlqau91yyy0xvWe//fYLvufpp5+u0e3zPke32bNn1+hnpfr3iuRUm7/H2qTfu//3j8qZMGFCcN916dIl3psDbBFdx7zjWdc3j8553vM6FyI6zgkAACDVEPQDAAB1xsSJE0May3X79ddfLREb9dWQp9vo0aMtmcyfP98uueQS6969u9WvX9/dOnToYLvuuqudffbZ9u6779aZsm5Jw6L/lpOTY507d7aTTjrJvvrqq7gFQXW78847yw0wTZs2rcqftXLlyuB3HS3gqs+7+uqr7YADDrCmTZvW+eBW+P7XLT093Zo0aWI77rijXXrppTZnzpyY16cG68oEtSvze4107JZ303cZfvzoNmrUqDLbsXz5cvfZ/uXCt/+ZZ56x008/3Xr06OH2UV0K3vsDNP5bdna2+z6OO+44d/6IFNCO5eYFvf3Hh3fLzMy0Fi1a2O677+5+/+vWratwexctWmStWrUKruOmm24qs8yYMWOCr+u7/f333yOWdUt888037rzZsWNHt68aN27szqXaP5dffrn98ssvW7R+1A367XjXnbfeeivemwMAABB3mfHeAAAAgOoSabSPnrv77rstkaihfOTIke6+GjCvuOKKMst88cUXwfvt2rWzRDBz5kzXcLx06dKQ5xcsWOBu33//vRUWFtoRRxxRqbLWddonc+fOdbc33njD3n//fTv44IPjsi36LVx00UXWrFmzal+3gn7edy2RgjVTp05NuN9jbQsEArZmzRrXIUG3l156yX744Qfr1KlT8Pfu//3X5u+1Ojz00EPud67AnefRRx+1goKCct9333332Y8//mippKioyH0Xb775prs98MADLhBcnUpKSmzFihUugKabAr06vjIyMqK+p23btvbwww/biSee6B7fddddduSRR9puu+3mHk+fPt2uueaa4PJ6fbvttqvW7Vbw5oQTTnDb799fa9eudefS//3vf7bTTju54HkqOuyww4LnCXWgSPWgn3ftGTp0qB1zzDEhr/fp0ye4r9QJBwAAoK4j6AcAAOqE9evX27///e8yzz///PP2j3/8o9wGzkS01157WaK59dZbgwGEXr162VVXXeVGYCiAoWCOGq3r6oitqtDxqNEyv/32m2sg135SA/Y999wTt6CfAnMKut1xxx1x+fwGDRrY/vvvb/369bOsrKwyIw/rsp133tkefPBBKy0tte+++86NeNR9jYJ76qmnbMSIEW65evXqVcvvv7K/1/BAo76bDz74IGTb/RScXLhwYZnP/euvv9z7Dj/8cPe4uLjYBZAq0q1bNxfA0bHxxBNP1OlRXN6+zsvLc8FxBdHk73//uw0ePNjt61WrVgWX1/70/1bCvyuN5Aw3bNgwO+uss2zjxo32wgsv2JNPPumenzRpkn355Ze2zz77lLuNCriddtpp7r06bw0ZMsQFpzXiTvd1zRX9njXqrrpdeeWVwYCfgjgK5qizwuLFi10ZXn/9dUt2+v0r8K6RkpXVunVrd0PFFBRNxDoVAABAjQkAAADUAc8//3xAVRvddt9990DPnj2Dj997770yyw8dOjT4+s033xx4//33A/379w/Ur18/0KpVq8B5550XWLFiRch79t133+B7nnrqqeDzH374YeDEE08M9OjRI9C8efNAZmZmoEmTJoHddtstcO+99wY2btwYXLZz587BdUS6zZo1yy0X6TnP1KlTA2eccUZgq622CmRnZwcaN24c2HXXXQN33313oKCgoNxyvv32266cOTk5gZYtW7pyrl27NqZ9vN122wXXpfVEsnr16kqVVTf/c37ax97z2vd+S5YsCZx11lmBFi1aBBo0aOBe/+qrr8qUV84888zgcyNGjAhZT2FhYaBp06bB13/55Rf3/GeffRZ8TuWIhf894d/bxRdfHHxex0m45cuXB2688cZAr169Ag0bNnTfz/bbb+/KsGbNmpBl9R2PHDnSLauyZ2VlBdq0aeOO+0svvTSwcOHC4LL+/eHdtP7Fixe718P3/++//x7yWXl5eYHLL7/cbbO2Se/dZZddAqNGjQo5rv2/jUg37ZuK9lc0M2fODBx//PHuN6Vj/YgjjnDbGe33GMm4ceOCyx588MFlXj/ggAOCrz/yyCPuuXnz5rnfR9euXd3vTOXv2LFjYODAgWWOo2j8+z/8GO7bt2/wtfPPPz/4fHm/Cf9vyju+q+v3Wpltj7at+o70/6BBg4LLvPrqq2Ver2j7/d9tecuNHTvWHZv6frbddtvAPffcE/jkk08q/dutaf5zWfh3+umnn4a89uabb1bq/bEcHzqH+N//0ksvxbTd+fn57pj33nfJJZcEbrvttpDvc/bs2VXa1vLo/ORfx6pVq8osU1paWubcGO38G+18Hn786jx8wQUXuPNpvXr13G802m/n5ZdfDhx00EHuGqRzcNu2bQMnn3xy4McffyyzrP8z9Ppll10WaN++fSA9PT34fes6fOWVVwbatWvnzjW6pr/77rvue/Teq99kpP3s/30uW7bMnU9U/9A2qRxa3zbbbBM455xzAn/99VeZ7dN7zj777OD1dJ999gl8+eWXEa+nEr5NEydODOy///7uvTomTjrppOA1xk+frf2rbdF26Xqi69hNN93kjjU/Pf7b3/4WvPboN659o2276qqrAuvWrSvz/YXfvO+6ouv5hAkTXB1Ox7o+p1mzZu67/9e//hXxuwcAAEh0BP0AAECdoIZ4r1FnzJgxIQ2TaswJ52/M2nnnnQNpaWllGox69+4dWL9+ffA90YIM11xzTbkNT0cffXS1Bf3UWKsGxmjvV0OVvyHfX041ikd6jz/gUB4Flbz3KHD4zjvvlAmM+tVU0E+NowqIha9PjYj+571Gyu+++y74nAKlJSUlwXWpUdV7TY2snpoM+h144IEh7/vzzz9DGtbDbzvuuKNrjPYMGTKk3P06adKkiN9/v379XEBa99XoXFHQT+tR42e0z1Ejrxdkrqmg3/z5813Ddfj6cnNzA126dIn4e4xEQQM1SGvZjIyMwKJFi0I+Q43vek2N0Pr9KKCphulo5dGxFotIgTMdf99++60LYHqvPfTQQ9Ue9Kvs7zWWbQ8Xvq06rvS/zqfTp093y+y1117B82mswbxYllPgNdJ306dPn0r/dmtaeYGwKVOmhLz2yiuvVOr9FR0fOpYfe+yxkPf/+uuvMW/7f//73+D1Uf975xDdnnzyySpva3l03fV+k7qdfvrpLrC0YcOGct+3pUG/SNcVlfmFF14Ivke/31NPPbXcc4N+a9G2q1u3biGPFfTTOnU+jfTZqp9UJuinc3h552KdO/2BPwXPdI2JVI4ddtihwqCfOkX4jwnv5g/8e4G1Ro0aRd0urUcdLTwK7pVXDnVuqY6gX7TziHfOAgAASEabJ1oAAABIUkqR9umnn7r7mZmZLj2a0pJ53nnnHcvPz4/6fqW6Uxo0zbV2++23u7SDovmlRo0aVeHnK02a5mLSHESffPKJ2xalRNt2223d62+//bZL5yevvfaaW9Y/d5JStXm38ubvW7RokZ199tluXiM59NBD7T//+Y+bQ8ub02fy5Ml27bXXRnz/jBkz7JRTTnFzOl144YXB55VKT/MkVcRL1yeaG+qoo46y5s2b2zbbbOP2n+bV8duSspZH6TGVMlOUak7pW1UmzU3mPe+ndIHeXFSaC+rjjz8O2UbPmWeeadVJc6Zp3inNZ/bcc8+555RO8bLLLgtZ7vTTT7d58+YFU+Up7aK+13333dc9pzSH/rkQvbR2+s6VFlLH28svv+zSBO66664hc6n56XtSyj955JFH3O8mGqWc0+9I6UDl+OOPt/fee8/tL6WKlM8++yyYJlTpCMPT6/q/a82pVBU33HCDO+698upY1++5d+/ebr7IWDVp0sSlKxSlDHzllVeCr2nfKc2eaA6zxo0bu9++0lSKyqvv5KOPPrJnnnnGpTL0ftuVoWNB379SDet4VJpNb9/q91PdKvt7rQ5nnHGG+54U5xgzZoxLBzlx4kT32iWXXFJtnzNr1qyQFLVK/6hzgFLXRjoHJCr97r20rh6lUq0OmuNMx5vOkeeee657Ttc2zb+3/fbbx7yegw46yM0DKvpela5VdDx555PqpnSXOhf603QrPaN+mzqXKDXun3/+We2fq/Od5gHW771///7BMl988cW2bt264LnzxRdfdPdbtmxpY8eOdeeGG2+80e1vnTv1O4hW59B55W9/+5tL2arrgn6P+l/nU9E6lA5a9ZHzzz/f1U8qIzc316X21Tlu/Pjx7neu64muM6Ltuvfee4PL676XSlfHitLI6rekOQM152gsv0V9Vzov33zzzcHnP/zwQ/vjjz/cfc3neeqppwbrGTr/aX7bZ5991jp06BBcz3nnnefuL1u2zD7//HN3X3Od6hytupWOA+0bpQHWfvLmP/Ufh6oXedcd//U9kv/+979uX3lUDn2W9r32g+YhBgAASErxjjoCAABsqTvuuCPYM/vwww8PPr/HHntEHEkTPorFP8JLlMLMe02ppyoa6aee8rfffrsbZafUVpFGDT7wwAOVGkUWacTC/fffH3xOKUj9ox40utF7TdtQXFxcppzqta+UaKKRBd7IJ91++umnCvezUmEed9xx5fasV3pJv4rKWpWRfv5RCUqH5tGIlg4dOkQcmfDMM88En1fqMSkqKnLpWL1RDZUZBRVJ+Mi18Fv37t3LjAD5+eefg69rBKdSxX7xxRfu9tprr4W85qWyU1o4Paf/lYKtvPSs/u9/8ODBgblz57qy6rHSuUUb6fef//wn5Fj7/PPPg9v14IMPBl9TurVYvstY9lc4HaP+1Ks6/j0a+ahUvJF+j9H873//Cy6v1HcepSv1nlf5RKPU/CMzNTLKn840VpHSq/pvOlfoe1m5cmW1j/Sryu91S0f66fhROljvPHTCCSe4+/qdafRWdY30UxpP73WlYlRZPVdffXWF51c/pSH0ju2q3GI5d4aPfot284/kKu/9VR1drZFW2p/edcAbCR1eJm+Upkdpj8PXpXPVlmxrRXRsRRqB5j8nKsWm35aO9POnAl+wYIFL9ei99sYbb5RJy/v3v/89ZL/5R5kqpXCk7Ro+fHiZsiplsff6scceG/KazlWRjo/y0l9rBLvqQholHWkUns55Hv8+9kaAi35T3rWmvJF+ShPuz4jgT63uXe+UItV7TvtU+9a/rf7zoX6PqttoRLae22mnnQKTJ08ud5RntBSoFX3/3vlJN32v/iwAAAAAyYyRfgAAIOlp9I3HP8LPf1+996PRCIJojysaTaD2PPWIVy9/jbJbvXq1ey5ceSMNYzVt2rSQ0Ws5OTkRt1nbsGDBgjLvP+CAA1zveNFoMI0I8KxYsaLCz9coAI0y0wi266+/3o1Ea9CgQcgyGvH19ddfW03SiEXPgAEDgvc1isUb0RdOo9Y0KsMbeanyauSAV+6jjz46ZH/UBI1kCD+e/KOSNIJz0KBBtvfee7ubNzLNe80bNXHBBRe4//Ud77nnntaoUSPr2LGjK4N/BFskGjXhjfLU7yba8e3frqVLl7rRrN52XXrppcHXFi5caMuXL7eaoM9dtWpVxO9aI9Z69uxZqfWpDN26dXP3v/32W3ccaZ9OmTLFPdejR4/g70gj+QYOHOju6zjZYYcd3OgjLaMRoVU5xjWCS6NPNIJFI3u6dOnizhX6zjSCt7rF6/eqUVE6z+g85I20Ufm0/2riHNC3b19XVo9+E5WhUT3esV2Vm//3UFWtWrVyI3Ufe+wxqy4a/aTjTSPINGJd1wuNtNIIQI1O8+g8E14m/yhKjYL1Rvr5DR8+3I1qqyn6fWiUm0ap6ZjSCD+NkvWfE3Uu1Ciy6uK/jmoU2dZbbx187J0r/edGjSz17zeNbPV4o+fCaWRvrNe0qhzPTz75pBv1rpHZGiXtjcyMVh/xXwP8n6XfVLTrqZ+21//bbtGiRfC+d3311100stE/yt+/z3U+1DlZx+rQoUPdcz///LP7jTds2NC6du1qJ598shtFWB3836VGC0cbJQ8AAJBsqNUAAICk9tVXX9n06dODj5VCSg3Ouqmh0KNG/t9//73aP3/SpEkubZ+oQfK2225zQQI1tiotmsdLHxhPCpT4KRWqJ1KgMho1wKlRWGnD1Kj30ksvhTS6K5VgrLwgpMffQKmgT3WpV69eMLCihmqlCfOn/qqJNHUK8ildnNKReY3USuvmTy9aGV5qtJtuusmlUlOjqBrCFfSbP3++e04Novfff3+567nuuuvce7Sv/enYqiqW1LCJwv89KwWvl6ZP/Ck2dVwq2DBu3Dg79thjXbBPDcI61yhYqgCigmmVobSXauBWcECp9pRm0aN0gtUZvKip32ssFFg95JBDgo+13yIFjVKZl35QAVele1y8eLH7LXqppavDVltt5Y63/fbbz6688spgEEX8x31F7rvvvmCqRQVeFKAUpX5UMLkm6ZqqAJZSxSo4r2uCP321zq9eZ4hwNXUt2dLzYlXTWsdK6a49+h3quqBjTd9jpPqI/xocfj2uzXpFOKXF1nVa1zSl89Q5Symd1UlC5VLnHQAAAERG0A8AANSZUX5VXfbLL7+M+riiubs0R5x/JI9G/GlE3e677x7ymp+/N3llgoH+kU0aVegPEvi3WfOX1UTDouYHWr9+fZlgmhrl/CMi/GWqqKzho+u8ue1E8wpFopECHv8oJTXyenMnRqJRId72aESN5mCU9u3bhwRoq5MCPWqE9Y+gUODPawzdbrvtgs9rtIQasfVa+E0NyN4cf3p85JFHutGragjXiKpXX301uB4FdcrTunVrNy+dF7SOxL9dCh4oYBltu7x5j8JHSWxpoFvBBR3Lkb5rBa/8o0dipcCHN1rIH/RTQ7U/KKKyabSJ5tTS3FP6LM3p5c3HqP1R0XxRFfE3iGtfefMnxvP3Wl38o990rGrUVnXynwP0G/DmOfU6glSGRm5GOrZjvVVlbkQF43TTvHH6LqoSbNmS480/sluBlPAyeSPjNRJK1zT//G+PP/548PHo0aODAcHqpGNSwarwoJGuF/75Tb1l/a9HupYogB8L/3VUo+RmzpxZpi7gPzdqfr9Ix4Q6lihoFUmk7zraNa0qx7O/3qGRiPr96ViLFoT0Rj+Hf/bGjRtdZ6nq4K+7KMjtzdMavs+1b9TBwrueKFuDrmca7afzr8oT6TpX1TqVf25LBRHD37slQUsAAIB42twNCwAAIMko6OVPZ3jVVVeFNJ6JGoseeughd18p9TTixZ8iTNSwdd5559lxxx3n0nOpIc9z0kknlbsN/sbzn376yX2WUlCpwS/aCAR/+iulaHz22WfdehT00aicaLQtGqWlhvwlS5a4tGwKZKlx84Ybbggup1FE/t721eX22293KcuUBkujlRTsUaBNacT8ARh/erKKyqqgTps2bdxIF2/b1dD33//+N2pjssqtUSaiNHVt27Z16RfVUO1v6A2nwMPhhx/uGoD9qdeGDBlS5phQQ/7+++/v7qucahjfEkqp56WL1HGigKNGkO2000626667umDlhg0bXMBYgSWl4dToFI0W/PTTT11jpDdCUA24akTVflbAUqODFODxxDJi7O9//7s7VqOlnVUQVNuQl5fnGpGVdvTcc891AUOl9FTDrb4jNRg/9dRTwREfarT1Gko1skTp4dQg6wU9ly1bZhMnToyY/s4LwioF5cEHH+zep33kBetHjBjhRnt06NDBpSvU/qos7a9DDz3UBZT9ae00mkjHoUfHo7ZZqfj0HSmIrt+df3RfZUfmKVWpyq79M2fOHDdi06PUs9q3laHjIdI2qJFf216V32t10UgcnWsVONB3GAvtGx0f4v0v2lbv2Nhll11cEFrnao2g1e9CAQQFMjWSV8tWNNI1Veh3q32q71zXNZ17IwU7olEg9YwzzggeY/pOFQQX7esnnnjC7X8FTX/88Udr3LhxxPX4R+Z5dP4vb5Sx1qt0xTpm9V0rOKrfh85X/uuzrh/+snTv3j04clUj/XVTBxld+2OheoCOW3XW+Oc//+mOX2nWrJk7J3ll91ICqwOHztM6h2tZnS91jlDAUuf0WIPduqbpdyk61nU9129W16rKjsTV9dXLaqBzgLZX+8CfsjW8XqF6Uvj1VMHdSGnCq0L7Tuderc87J+j3q0Ck6jQenZu986CCrEqdrnqC3ltSUhJSJ/Cf+/z1DI1q1L7Ud6iylNdx65xzzgl23tD35l3ndFxpn+j3w4hCAACQlOI9qSAAAEBVvfjii4ouuFuTJk0ChYWFZZbJz88PZGVlBZf74IMP3PNDhw4NPtejR4/gff9tp512Cqxbty64rn333Tf42lNPPeWeKykpCeyxxx5l3tuwYcPArrvuGnx88803B9dTXFwc6NixY5n3bLPNNsFl/M/PmjUr+PxLL70UUp7wW9++fQOrVq0KLu8vp38bpHPnzsHXPvvsswr395577hn1c73bqaeeGvKeWMp6xx13RFzXjjvuGLyvfe9Zs2ZNoGfPnmWWz8jIcOuNVl4ZP358mfdNmzatzHLaH97r2k+x8L8n/HuT3XffPfhanz59gs9Pnz494j7y3/zlj3a8erdRo0ZF/P4HDx4csj133nlnmff+/vvvwde/+uqrQLNmzcr9LK3fb8CAARG/l2j7KNLNv7/nzZsXaNOmTcTfV4cOHcr8HmPx5ptvllnff/7zn5BlFi5cWO42ZmZmBr755psKP8u//8u7Pfroo8H36LjxvxbtNxvtdt9991X59xpt2/3Hn1/4tvqPn0j859Dw36f/tWg3//d8ww03RFzG//uI9bdb07Td0b7T6nx/LMdHo0aNAlOmTKnwM0eMGBF8T25ubmD+/PnB11avXh3o2rVr8PWzzz476rZGujVt2rTczy4qKqr070ZeeOGFCq8l/mMi/PjVeTn8vWlpaYFnn302+B5d80855ZQKt81//o/2vP86uc8++0RcT/fu3SOeb/372f/7HDduXMT17LfffhH3geo4/v3j3bKzswPbbbddxN+r7kfapmj1JJkwYYI79qLtLx1PeXl5weXr1atX7v59/fXXg8v+9ttvgfT09DLLeMdledfz66+/Pupn9O7dO+oxCgAAkMhI7wkAAJKWP12nRur456nyqIe+N2JLvLRlfholot7e6lGulH4adaPe3p999pkbdVQejUZST3CNdtBIIc15pM/TSLFooyk0qkxzeGlesIrWH2lbNTJRI+I0EkujvDQ/m7b9X//6l+uZ7k+JWJ00MkypKtUbXyMqtG9VFvWyV5k18iN8REUsZb366qtdr3/1ytd32KtXLzcqRaMoIlF5NY+i9rlGl2nUiEYrabSbRsFVNOLA3/Nf7/PSidU0/8gujbzxUs5ptJxG/2kkmzdHn9IwakST9ptGaGhuOf/ImRNPPNGVQ9+19rH2g+bu0v7X/F2xUIpP/+i2cNo3Gu0wfPhwN/JD35/2tUayaiSgRvLdeuutIe/R52t0RrRRP5WlUX1Kb6eRIVqn9o0+WyM+Kkq9G034qD5v9J+fjm3Nz6njRd+Dyq3Rs1pWI480mkSjGKtKv1uVTeX66KOP3PkmEX6vyUSjmB588EFXNp03NKrqlltucc8hlK5rOs/oONOoL51nyqNRT3feeWfwsfapjn2Pfos6dry0ijqWoqVjrgr91j788EN3rtM5Xd+tzj/e70a/QY2ADv/daE5fpYDUCEEtqzJrVHCsoz91zdfoQF2LdA7WyNLXX3/djXj0qMxKC6yUyhr9qDTE2l7VG3Tt0uj7999/312fY6XfpUanKXWpzk36bKULVwrLU045pRJ7ztxozIcfftiNBve+d6Vh1fUlEu1XlVtzmnrXU+1zjST2XxtVt9kSSk89depUt30ajajfrD5LI6mVQlajJzt27BhcXnOeHnXUUe6713lf+0j7Wvtc+1fHgEcpV1Vn0HWqsvNi6vqqeZg1qlvHlt6vUYL67pV1AAAAIBmlKfIX740AAAAAaotSW95zzz3uvlLFKaUbACC1KG2zOjF4UrVpROUOn2tQ6TPVsWL+/PnBtKNKuQoAAIDEx5x+AAAAqPM0H5DmgNMceRqh4Y1WqewoCgAA6pLBgwe7kd0a4af5SzXnqEZ6egE/jXzUCGsAAAAkB4J+AAAAqPOUjtGf5lVuuOGGaktDCQBAMpo7d679+9//jviaUmsqnWllU5EDAAAgfgj6AQAAIGVoXiDN0aZ5hTSXIAAAqUxzFmoewT/++MNWrFjh5ttT2tOBAwe6eQY1RyIAAACSB3P6AQAAAAAAAAAAAEkuPd4bAAAAAAAAAAAAAGDLEPQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDAAAAAAAAAAAAkhxBPwAAAAAAAAAAACDJEfQDKrDffvtZWlqau82ePbtK63j66aeD67jllluqfRtT0cUXX+z2Z48ePSwQCFhdd+aZZwaPoQkTJsT8Pu89Xbp0sWSh8nnbrXKnqoMOOsjtg8MPPzzemwIASUf1Le9aonqYR9dD7/lEuI5yzQMAAEBdEa39szraVuuiRGizi/Z3E5IbQT8kDX8jTUW3ygRFUo2/cSmZAkF+c+fOtccff9zdv+yyy4INd6o4hB8L6enp1rhxY9tpp53smmuusRUrVkRc57p16+y+++6zffbZx1q0aGE5OTnWtWtXO+KII+z555+3jRs3ltl/0W5Tp051y+61117B577++uuQz9t5552Dr40bNy7ktdNPPz342muvvVbuvnjrrbfcBVq3La04he+/RKPt88qqcldHADWRg/BXXnml+//999+3b775Jt6bAwDVyv+H/5NPPhlxmeuuuy64zLnnnmvJavTo0cHrVyLz/8Gv28EHH1xmmcmTJ5ep9xQUFFiyCy+7bpmZmda6dWs75JBD7IMPPoj63p9++snOOuss23rrra1+/fqu3tmrVy+79tprbfHixVHfF2vdM1YLFiywjIyM4PY3a9bMCgsLK1UPiuXvhI8//tgGDx5sW221ldtm7aPddtvNRo4c6eroAFBX24Sqcj33B0C8m87VzZs3d3Uhne+jmTlzpl166aXWs2dPa9iwobvp/iWXXOJei6aoqMjVrXQd1zm6Xr167pw9cOBAe+SRR2zNmjWVKreuJbqm+Ldf15zyrqXhHZliaWv47rvvbNiwYbbNNtu466n2UZ8+fezqq6+233//3ZLVpEmT7Oijj3bfRVZWlrVs2dJ22GEHO/XUU+2ll16K9+ahhlVnm11lqf3z1ltvdfW03Nxc97vq1q2bnXjiiW67UmEARUoLAEmic+fOOhvFdPvss8+q7XN/+umnwBdffOFuBQUFVVrH4sWLg+uYM2dOIJ60b7z9pH2ajP72t7+57c/Ozg6sWrUq+PysWbMqPDZ69+4dKCoqClnfr7/+Gth6663Lfd8PP/xQZv9VtOxVV10VfG7UqFHBz1uzZk0gIyMj+NrQoUNDtse/LXl5ee656dOnB4+hlStXBpfVe8s77ivzXYfvv3hR+byyqtwe/74P32eV4d9nN998cyBRlZaWBjp06OC28/jjj4/35gBAtRo3blzwXDxo0KCIy2yzzTbBZT7++ONKrV/nd++9Tz31VPD57777LniNiUV11Jn8ddhYr3nx4N9nuqWnpwdmz54dssz5559fpt6zYcOGQLILL3v4LS0tLfDWW2+Ved/999/v9lO09zVv3jzw+eefl3lfZeqesVJdM3wdb775ZqXqQeX9nbBx48bAGWecUe42X3755ZXaZgBIhjahSJ8fK9VBKtpWXUvC/fvf/w7k5OREfY9e0zLh5s2bF+jbt2+5nxfp2lCeN954o8w67rvvvnKvpeF/r1fU1nDNNdeUu81HH310IBmp/pqZmRm1XAceeGCgrvEf8/56RnW0rSajitrsvH2iv1Gqk+qfrVq1Kvd3lZ+fX+7fTUhumfEOOgKx0ognf09i9UxYtGiRu//AAw+4HkAejeqK1qNWvaMqI9q6KkM9enTDlisuLg72hlP6wyZNmkRd9osvvnA9V3744QcbPny4lZSU2I8//mgTJ050veq8ni+HHnposGdy+/bt7e9//7v73tUD7n//+5899dRTEdfftm1b+/e//13mefWckd133z2kd5c3cks92LQtHv8owCVLlgR77XXo0ME6duwYXKe33rquadOmbpRkqlMPyGOOOcbGjh1r//nPf9yxqt6OAFAXnHDCCa6nuq7rn3zySZlz3JQpU+yvv/5y99u0aRO8bm+pfv36WSJJ5GteaWmpPfHEE66HsFePfvHFFy1RVKVeHwvVC6+//npbtmyZ65WtuqPqkw8++KDrqe9577337PLLLw8+1ugEjYBbu3at3X///a4equNa13KNBlS9bkvrnuWJNFrg5Zdfdp9fHVSPfe6559x9ZdLQ6FuNStRov59//pl0UACSok0onpTtR9eS1atX2z333GOfffZZcNuVwcij9ovTTjstOOL7qKOOCmY8UMajt99+2+0HZQjadttt3XpFy2tZ1aFEo/P+9re/uXYJjdZTm4Su69V1fbniiiusOmhf/POf/ww+1rVUN7X1/Pnnn/bCCy9YoqqoLjJixAhX15WLLrrIjjzySPdYbT6ffvppxBH5ia6q9a9E/E0mgpr4O0B/Q+lYW7VqlXusaZHUJqo2RdVv//vf/5Y7yhh1RLyjjkB19LLy95bw9yDad999A//73/8Cu+++u+sJ5fU2evzxxwMHH3xwoFOnToEGDRoE6tWrF9h2220Dl1xySWDp0qUhn6N1eOvTuiN9xrfffhvYb7/9AvXr1w+0adMmcMMNNwRKSkoq7OniX/ePP/7oPl89MbSthxxySJne1VrnyJEj3egffZY+U72AI21jdY30+/PPPwNnnnlmoGPHjoGsrCzXY/nQQw+N2ONevfbVq6xhw4ZuFF779u1dz6V//vOfIWW4/fbbAzvssIMrp/a9vofDDjvMfS8V0fcZrUdceb3H+vXrF3z+pZdeCj5/3XXXBZ9v2rSp6xkXaaTm8uXLK73/5s+fH1xW+89z5513uue0D7ze4ytWrHCvqRe59x7/6K7w3kEVjWr0fhP+bdV7jjnmmECjRo0Cubm5rre+v3d+ZUf6LVy4MHDppZe6nur6vrX/dCy++uqrZZZdv3696/3dsmVLd3wceeSR7vMi9ZaMNKLPf4yH37xlli1b5sq01VZbuWNV5ezWrVvg5JNPDkyYMKHKI/3Ug1K/NZVP5ezatWvg4osvDixYsCBkuVg/X+U+5ZRTAu3atXO9/rTe7bbbzv3OdB7w8x8Pzz77bIXbCgDJRPUJ7xz32GOPhbx27bXXBl/TtcarA5xwwgmuzqZzp861OpeeeOKJZc6f0XqsRuulr/qfRjE1adLErVv39Vyka77qCsOGDQv06tUr0KJFC3cu13V1//33D+k9X1Hv/opGscd6na1svTQa/z5r3LhxsP7ivfeJJ54Iec27+esSw4cPDwwYMCDQtm1bt8265vfp0ydw9913l8m0IJMmTXLfqb5HfZ/aXh0X3ii3WOr1MnnyZLcevd9bj+pR33//fYXlDi+7f72vv/568Pnu3buHvGennXYKvqZruJ96sPfo0aPMMVyVumcsZsyYEVznnnvu6erWuq+/c9auXbvFI/1+//33kBGNDz74YMQMBdOmTYt5mwGgptqEvOw6Osd57Q66duk68v7775dZz2uvvebOnaoDeNcQPb766qvduS2W63k0/vfq8/3XLe95XS/99Ley95rqFtoGj+7rOe91Let55JFHgs8rs1CkEeOrV68OZhOKhfaj6hNap64te+yxR/AzZs6cucUj/XSt09/N3vPK6hTJb7/9Vu52RqoL7bPPPm7bVce48cYby9RDtC+ffPJJVyYdHzpOVLcbPXp0mXqT/1hT9q7jjjvOHS9dunQpd7u80ZpqR4tk3bp1IY+jtTXF2i5Z22X+5JNPXFub2vVUXx0zZkxM7Z/+dsvK1B0r0yZalfpxYWFh4B//+IfLEKY6lJbV/rnrrrvca35Tp04NHHXUUa4NV38L6DvW+9QmpP1VlTY7v+Li4sDYsWNdvVf7Xd+V/gY677zzAhVRe5O3Xn0v/gxpnr/++itYpmh/N1Wm7TzWdq6K9huqD0E/1Omgn4JO/pQIXsVDaaSinXh1UvI3XlR08dAJzasE+W/+xqtYLnqRUvyooul32WWXlVlGJ1JddCNdPCOpTNDqm2++KdOw490UqHrooYeCyyogEW2f6oLsufXWW6MuF17eSLyAmW7hqbkiVSRVqdFFRRdJ73mlFfD49/stt9xS4edXNmiqAJC3vFe59irxd9xxR6B169buvvfHh7+RU5Wc6gr6NWvWzFWiwpdTRae8/ReNKviR1ufdlJ7DT+k4wpdRxUEX+OoK+h1wwAFRl/GXszJBP/2hF22dKr//D51YPl+VVjUaRlsuvNF77ty5wddUCQKAusRfdzjooIOipvb88ssv3XP6gzva+VN/iPobhCoT9NMfvGpcCF+n/siPdM1XoKq8a/AzzzyzxUG/ylxnK1svjca/z/QHuho+df+9995zr/fv3989VmODf93+erMaA6JtswKlfmp08qc799+87yyWev3bb78d3Nbwm57X65Upu/97UEOw97waiiIF2XT75ZdfyqxTgTHvddUHq1r3jIU61Pk7xV1xxRXBxy+++OIWB/389Xc19qghCgAStU1IqbP9HTPCb2pI96hzZnlpmvX3W00E/dQpxXveH0RRZ1kFPrzX3n333TLr/M9//hN8Xct612H/36PhnVGq6vnnnw+u88orr3TBIe+x2ma2NOjnrwuqbStScCIW/vWrw5ICR+HfU/jf00OGDIn6nQ4ePDjqsea/jlfUJuRPr6i2np9//jkkiBsu2norapeMR5lVP/cfq5Hqz7EE/SpTd6xMm2hl68fqsKWgabRt0WtekEwdvstLnfnRRx9tUdBPKdXLa7cuj8rhL+vTTz8dqEi0v5tibTuPtZ0rlv2G6pMe75GGQE3S5MJKj6hhy++//34wvY1SBWhiY6Xl0QTP+n/IkCHuNU0Q/MYbb8T8GQsXLrRddtnFpVjwp2TQBMmVsXTpUhs3bpzbVqVhkC+//NJ+/fVXd/+PP/5wqSC8lDpKE6CUf5qQtSYmg9W1R2mKvEmelYZL++mmm25yn6/Xlc4hLy/Pva7yS2ZmpiuHUnUpDYPSSXTt2jW4Xm85lVFl/fjjj+3ZZ5+1Cy64wNq1a1fhdvkncFYqi4rSI2pble5CKTT0+LrrrgumFVD6Jf8E2HvvvXel9tGcOXPKTMqtycX9wlN8yjfffBN8bcCAASEpPr1lwt8bTvtKaaOUHsqjtCB6Tjd/ahNZuXKl2+evv/663XbbbVU+Tj1KTeGlUlHKtXfeecdGjRrlUjyJ0nN45VTqAO971+taTpMGt2rVyqW4ioWOfZXPo3J7Zb3hhhvcceqlR1HZtT0ffPCBOxaPP/74KqWf0Pb/61//Cm630o5ovfvvv797TuXXfpBYP3/atGk2ffp0d18TqY8fP97effddVz6VSZOs+3Xq1Mmys7Pd/d9++63SZQCARKZ6mXfd0DlU6WbCU3t27tw5eK1UnUfnS51jtfxHH30UTAe1fv16u++++6q0HUqlqFRa0qJFC1dHVPpu1ROipff+xz/+4a6pqsdoW5555hl3XZPbb7/d/X/YYYe565SW93jXLt2q6zpbE/VSpVRV6kYvlZjSN3qfd84550R9n67JSgOm65vq2KpT9+/f372m9I/z5s1z9+fPn28XXnhhMN25joU333zTpW5TCjPv2ldRvV4pps4++2wrKipyy2ides27Put5va7lYqVU60oFr7qKv850/vnnB+/7r8na1u23377Merx0a6JUnjqetrTuWVHqNdVFVe9Qvd2fgm1LKcWpR7/HjIyMLV4nANQUXYt03fKuxWrHUJuDdz1WumKvHUNtKkpnLXfeeadrx9B588Ybb3Tndp1Xt+R67qdUe7q+6DqltM6Rri8zZswIpvUMv5ZEek7L6j3h5+rqvr6Iri26xmif1MT1pVevXuVO3xIr1TX23HNP993qOu5ds1QXUrptUX1Dx4SX+lDl1PJeG8wrr7zibpEsXrzY1cnUzqF04OXR3/we1R3VFpWbm+vSsGr9m2I+lpRlVlufd6yqnN5ne22YsYq17rglbaKx1I9Hjx5tn3/+ebAdRinttV1bbbWVe06veX9rqN1ObbhyyimnuL9JVG9Um9G+++7r9n9l2+z8tNyHH37o7jdo0MDtV+2fxx57zHbddddyy6qUuBs2bKiWc0GsbeextnPFst9QjaoxgAgk3Eg/9diKlGZGo2fOPfdcl6YvUq8S9WCKtUeNerYsWrTIPa+h4epp7o2sqsxIP/9EyBdccEHweaX3E6XIjJT2UWkh/b04qmuk35QpU4LLqae5epp49Pnh260Uhnqs8iv1Z7QeWhqa7o3+U0/58HQGlUkFFj75b0U9adTbW+kivJ5VSqfkf12piyri33+RbuH7VPvHf1xpCL3uq2e7UmUodYAea8i8ek17x4+2Vb38Kpr8t6JJgf3b5k/v0bNnz+Dz6gkZaf9FoxQcGumpZfT7UW8dj/av936l85QLL7wwYroO/TYjfV60UQ/lpUDTvvJ6aGq0iEZ7REojVpmRfv5eZP7tVhoD77yh/aD9Eevn+8us1HE6HipKuabUE15PKgCoa/x1CqWlEo1i857TiGuP6gwaGaXe+9710n/TaL2qjPTz1y38vf/V2zTa9V29Zvfee29X3/Ouif6bvx4ULaVotGtbZa+zla2XRuPfZ/oONMLPq5OcdNJJwd7bEm2k38SJE93oftUdlbInfL94o+789SOlmIqmonr9G2+8EXxdKeb99Nh7zZ92taKyh9+UlcEbvRlp5IN6j0cSXs9RvbMqdU+lOlJ2C/9t+vTpwdc1asBbn9Jjieq6GhnpHRP5+flbNNJv4MCBIccGACRqm5CufUq57Z3/1DbhnTsvuuii4PL33HNPmUw7mtbBf80t7/NiVd4oQaW19LbDfx31LxOeUlDUDuJfRu8R/3X3gw8+qHDblEo6/Priz4qk+og3kl7tN147itemo1u0LAuxjvQ755xzoo40qwz/+lX38do45LTTTgu+ppHr4ZmIHnjggWD5NSLJe/6II46I+N0/+uijMW+Xpnzx10fCb0qZ6Ret3llRu2Rtl1nHjvea6qr+lOT+z45lpF+sdcfKtolWtn7sH6Go0bSRRtYqDaWMHz8+5G8VtTFHG8EZa5ud/zvX54T/fRSr8HOIv54eTbS/m2JtO4+1nasy+w1bjpF+qNM0Sal6sPhpRM4ee+zhekjMmjUr4sS5GhUVq549e7re0F5vE/Xaqew6RL0aPOplHr4t/l7BXq8X0edpG6qb10tD1CMmKysr+Fg9acKX06hA9fhST3v17GjatKnrHaPJpb///vvg8upt7fXwVk/hRo0auRF76t3m/8xYVNQryutBox46W2+9tevtfe+99wZHjGkbw3uQV4Z6+vl7+Omm3lPljfTzRvTtsMMOruze6IVvv/3Wpk6d6vaf18utfv36Vl3UY87fIzDSMRYr9Rzy9v0222wTsq5Ix0a0Y1e/Te/3sqW0r9RTSNRbSL0y1SNKvafUA8ybwLgy/Mejf7tbtmzpjifRflDPylg/X+ckr6fVc8895/afdxzcfffdEc9H1dX7DwAS0cknnxy8/+qrr7r/Ncou0us6z95yyy2u9753vfSr7PXM479O+XvP+q9pfurle+aZZ7rrvj4z0nm6qttSletsTdRL5ZBDDnF1OdWfvO9Go/CiUV1Go+HVi1qjFIuLi8ss422Hf9sPP/zwKtfro12rY9lXsVKP5PBe6/6RCMuXL494DHg9mT2qd1al7qke1qo7+G933HFH1FEY/hF/ol74/iwm3ggNCd9u/2MdP/5tr8w2A0C8KGtAfn5+8Pyntgnv3PnQQw+VySB02mmnBUehnHjiie5vPV1HjzvuODeavyZp9PfkyZODIw0lfKRb+LUk0nPeObqy52qNOAy/vlx66aXB15XRwBtJr/3hXT+0nyJdg2K9vviXq4nri+pC/vX66wNenc9fL9DIL6/8/nqOP8uU35FHHhnztrRv3961A6lupLqjPwuW6Pqs0XPJVmZ/3Vl11ebNm0f87IpUpu64JW2isdSPo9UpI9Untd9ULxVlh9JoQO1/ZedQW7P/N10V/m3xMm/EakvbOavSdh5rO1dN7zeEIuiHOs07qfspdZA3PFwnfg1fV6ONPyVUZU404UELpbesCv96/OuI1IjgryTFQ6TPP/jgg106UlUYFOhQwEP7WSk+FdD0LtBKCaW0h2eccYbtuOOOLiWSUng9+uijbrmKGqVUCfd4lflo9tprL3dTI6FSdXi8lAW6CHnBG9H2V4b+OPA+w7v169cvZBkFTL0/IpSuTEPi/cFALa/vW+VWerFYUntWRXnHaXUGlSo6Nmvy2NX+U3oGpcpQJUMpwxRIVSoEpSWoTpHKEcvnq4KpP64UfFZjqio5Sr2gYPDVV19tl19+eZn1er8J/7EPAHWFAj6NGzd293WNVDoYr86gAI+X+kbpEZXi0rt+q+FOy3vXVanuPxSjXbO81EKic7dSgaku6aUPr4ltqWibqrte6l2z1KnLo9Si6swVjVJae42DaqDQ9U77xUsDtKX7JVK9vibqHEOHDnXl0LGo+qzqSWqYUAopjz+dpxqVI6Xg9qcsU/BUx+2W1j0j8afiUqotL+W8/zj1p2Dzfm/ipdSN9Ni/XO/evYP3VWfx0rICQLLy0j6rTUKBNwVB1NCvBmileVa70aBBg+yrr76qts9Ue4fOn0qX7V3TFDQbO3ZscBl1iPanuNbfk+VdX7SsN+2J/1xdHdcX/7VD1xTv+qJrTaRr0JZeX5SG0ptepjpVtT4QLTV4Zesj6kCvNgK1F6iOq85r/iCV2onChV9nw/dnIpe5Mp9d1bpjZcu3JfXjSJ+l+qF+Y7feeqsdcMABbkCAjt3//e9/dt555wWniYkHBdX8Awiqei6oTNt5rO1cibzf6iKCfqjTIp2cNcLMc/HFF9tJJ53kgjUFBQWWyBRE8Hz33XchgS/lT65u3bt3D97XPDf+Hjf+OWS85dQgol4cCt6p0qITt074ot74ajjxltNFQLnEVdlR7zbNDSjq2VNRpXq77bYL3vdy18fCH9jyzyPnDwYpR3mkXjCq9Mc691w4VcIV+PMahTTqULwRfrroeRVd5SuvbNDP3wu7tnrF6I8K77elgK16uJd3bEQ7dpWTvaLAbWXKqoqbKgrqJaZjQ+tWzyRR77nKzOfj336vB5pH5fXmmtJ+8P7IiuXzdRyqwW/48OEu+K15IXV8eT3+wucTVSO3lyc/0nxBAJDs9EepN+eyGjh0Ho00ys9ff1MjnOZuU+NZ+FyoVeEPwvizE0SaM8+/LRqBp7n19EergpP+bdySa3Vlr7M16ayzzgpuv0aOefNOR+Iv/1133eXm8FAdW/PAhPNvuxoJqlqvj3atDn9c2X2la7qOMzVUeDSvtUd1GzUU++uQfrp2jxkzJvjYO8arUvfU6FbVH/w3r86oMnp1kvJ8+umnbp3iHy2pgLW/YdGbP0b8DZIa1eEdBxqJqvp+OG2X6nYAEE/qKOk18OvvLrVLhJ9Ddd7zOtzqsbLw3H///a6BWh0uvew9umZrvqnq/Ntb69DIIW9OYtHoba89SvUidaj2qIHd35ah+/5Gd12rvPl+/dcXtbd4c7n5aX94DfkaeRa+b7zOVJoDzd+xqrwRSV7Qyn99UbuOf27kaNcXdf7S9yTKjuPNixwu2gi0SHQtWr16dcS6k1fn89cLNDdz+H7QLdr1tTIBJ/3NH36sqP7gn+fNfx32Rmmp7ucFwzRfXUVtfrVdZv+IRQUy/e060erPW1p3rOk20Wh1ymjtn5rLW3VD1aX0e9F+8I5lf7tOVc4b/m3RPHqVob+N/PXOkSNHRgyma3v984duSdt5rO1cldlv2HJV7/oJJKnOnTuHpMvRBVAN9NEqF4ni6KOPtmuuucadJJVmQaOHFExS5dQ/SWtl6OJ47bXXlnlef9hr3QqwqXKlE7HSXqhSqAueenx4AS0vdZB6xmm5gw46yPVmVmOJf1Jrbzi30g6pZ5eGdXfs2NEFE/0NbJGGjPtpcmKPKpflTUqrSbK9i5W/ocZ/Ab3qqqvcaEQFV1TBV+8+Pafe+rowqqKrPwj0vz9lgbet3mf4af2tW7cOCeAppYN4gSd/UE8BQPUu9AelYg36+XssPf/8827iW910Md5SkY4NpUfRTX9cKJCrfaCLvyZDVwXRnzLFS3epCof3vBrA9L2r549691SGv6za76pM6Fjy9rcqgToeFURVGg1VMpSGQPS70bY2bNgwZJ1K2RKp0qJJtrX9XipYbbfWqV5TmuDZO061H7zjIpbP129O+0/7TEE89ZjTMl6KlvDjXwH3SMc+ANQlCu4pFYzk5eWFPB+p/qYAhnrG63p3/fXXb/Hnq/e1rimilMxqcNMfn9ddd13E5bUtCnyoQUbXC6XkVn0sWgchXb+864F6yvft29c16vhHBvopmFiZ62xNUlk1AkEds7zUkeUt62+40Yg57Vd/Q5+/rql6hsqnHr+6fqpXtxpDlCZb1zzVPSuihlHtL30Xqk9ecsklrgFRgUSvfqkGYNVPq0JpztTrWB3YNLJCnXi8xlhlkdCx4/1NoQYxlUv1OdUfvAYoff/+4OGW1D3D+dOqqbE3vP6nxmovsKe0uWq0Ub1MHe5UB1cjod6juom215+m3v99q4FWgXZvNIr2izrvaV+rcemXX35x26wUXaonAUC8qIFd10ddLxV00jlbbRW6FijYpfOVGpZ13lZKOZ3jdb7V+Ux/o+rvRf91y//3WWWv5+XRNU5tFKr3KMChIJ3X8UmdPbQNCvroHK7UmpomRdeZJ554wj3ntcdoWY/aazRyyuu0rfLp+qIgo8qhNgm9/+GHH3Z/k5dHab29AIWuEWqP8lNbj5f6W9citR+pE5R3Tdb1TW0aep86t3j1vPDri65zN998s/397393j/V9aJ+o7qNUpwoq6pqp9foDsOXRdVjXRNUJdO32j1j0yqH9r866oixUN9xwg/tbX3+Xq46nQIsCUNq2LaFMWPqetD36HtR5Stdbf5Ynf2p5dfxS25Da+E499VTbZ5993LFc0Qj72i6z2jFUf1H7oNpTVGfX7yz8sytSmbpjTbSJ+ml/e4Fy1ZdUJ9Nvzt8u5tW9FdRWeVV/1T7U+UXv9aYfCD9vVLbNTpk1vBG9+htAbUs6TtS2qY5XXvtiNNo3qgsrkK6/H3TsKSCn40u/T+1fbYvacP0ji6vadq7tiqWdqzL7DdWgGuYFBBJm0ubwyVo1UWy41atXB9q1a1dmAtI999wz4qTDFU2YG/4ZkSZ39k/eHMtEttEmUb3sssvKbHeTJk1CPtO/nki0r6JNIhz+md98802gcePGEZdJS0sLPPTQQ8H1nn322VHXp0l1NZGrHHjggVGXa9OmTcjkw5EUFRW5CX7DJxkO/16i3TT57FdffRXyvl9//TWw9dZbl/u+H374odL7z/Pqq6+GvK6Jxf2T1b7wwgshr7ds2TLmyX/9kwr7b+VNChzLcR3t5h2/+j697yHS7Zprrgn5PP+k0d5Nk4E3b968zDb797H/t+j/7iPt74yMjKjbM2jQoIj7MtrNo8mFoy2jbZk5c2Zw2Vg+Py8vr9zPPf/880P228UXXxxxcmwAqEs2btwYaNGiRcj5UBPYhzv88MPLrb/5r3XR6lKR6mmFhYXu88LX3a1bt4jrvvvuu8ssq2t3jx49ylxb5W9/+1uZ5b36Y7RrXmWus5Wtl0bj32fh1/Fw/m3ZsGFDsN6o+qH/NT0eMGBAxO/iscceC6Snp0csn7dcRfV6eeuttwJZWVkR16Pn33777UqV3f89+K/Fug0cODDktXvvvTdqGXRr1qxZSL2tKnXPaEpKSgLt27cPLv/zzz9H3Dfe63vttVfIdpf32cccc0xIXdX7nZ5xxhnlvu/yyy+vcF8DQE23CeXn5wd22mmncs9X3vK33XZb1GV0fp84cWJM1/No/G1B4cv66xPdu3d353XPSy+9FMjJyYm6bXrt5ZdfLvN58+bNC+yyyy7llv3NN9+scN/uvvvuweXV5hBu6tSpwde32mqr4DXjlVdeKffv4t122y1Yb/BTvaO8bVZ7Qnn89QUdF2onC1/HOeecE/KeIUOGlPuZ/ra7ytSn/NTmUd5n7L///iHX20ceeaTMMo0aNQp07Nix3PabeJT5888/j1j/8tefK2r/rGzdsTJtopWtHxcUFAT23nvvqPtmn332cX8zyBdffFHufrzrrru2qM1OdS7VOaOtPxb6flq1alXudupcGe3vpsq0ncfazlWZ/YYtR3pPpByNDFIPYvVCUi/uDh06uBFHlR11FA9KAaSeXBpFpBQOGuWmYfn+niNKF1ld1BtEvYzU20b7SaP39FlKz6mezurx61GvIS2nlA7q7aaeKxp9pd7E6gXmpRS46KKLXA8kb2JXrVPr1vs1eit80tlwWt6bT0bfYyw535VDXZ+hXifqTe6l1vSoJ4p6l2j/qreNepupt4tGLKqn/TPPPLNFqRXDP0/71Z8eIfx1/6TBFVHe83vuucftzy2Zt6ey9H1qpKV6kmnIvvaxeuKpJ5pyfWvkg596/6lHj3ro6RhVT8rPP/882HvQn3M8GpVP8znpO/LPA+BRj3t9X+q1qF7nuul4VK9B9W6vCqVdUQ9GpZBT+VTOLl26uJ5fKr8/rUUsn+/1ZNT62rVr59ansmuUiHpM+effUf3P682oibMr6u0PAMlK58LwUWT+UX4e9RJXXUO9QtVTWr2U/fOsVZWu+apTqC6ic71uqjNES2ulHrc6Z6sHrK5p6kmv0YealyISnffVe1/1t1hTQlX2OpsIVL9RNgiNeFA9VenSdP3zpynz0zzPqiNqBIN6BOs6r7qjepnvvPPOMX+uen6rx7OOIb1f61HqIK1XPYq90XhVpVFxXmomZQjwj8JXr2nVlTW6QvUDXfs1SkSpuzS6T3P96fgIVx11T9WjvNSgOkb86UY9GuHopX1THdgbSeulX1J9TPtK+0zHl+qkGs2nEX/hx6qOQY1E0d8AGtGo+o62WXU79bTXiBWtFwDiTXUEXRc02kVZWPT3lq7XGlmia4X+NvUy6xx22GF2/vnnu3Oo2jrUjqFzsq5dGg3jz7ZSlet5RaPAvL9rNaLNG4Xl1YM0KlHtJ8psozLopvt6TqOtI81br3YPpSl9/PHH3cgb1Zl0/tY2629QneMPPPDAcrdL6SS1DtF+03rCab9qZKRo5Lo3TYvX5qLrhD5T1xe1++g6ob+XVbfyrkt+qtcopaLqebqmaRm1Del7Ub1Lo8Bipeux5gjT9Vf7TPUzZYbQCEc/XWt1XdN+0WfpmqYyaf9oxL7285bSqDeNFNP11btuap+qnqO0rhqN5T+WVDdSpgnVZ7TtardUXcmf2jJRyqz2SG2/vlutR/VitZ9Ey5RRHXXHmmwTVR1Ofw94WTy0H/UZ2jYdf6r/eKPi9DvUqEOdR7w6rI5zjcbTb0yvbUmbnX6zqqfpO9E+0rq1LRqpp/NGLLRvlLlN6T379evnvm+VUb8vtdNqtGR57a+VaTuPtZ2rMvsNWy5Nkb9qWA+AWqCfa3jlUkOzdZHWcGhVbvXYnzO6LlKDhS52yj+tVAf+4COS59hVWgtvjkZVBvwTkmPTHEdqjBOlzVBlDwAAAAAAhAYqvQ65CjzEMh9hskvFMtMmCsSOOf2AJKLeIZovRj1FdFHT5KjqVevlP1ZvqlS4uKkXtHpAKeCneUMuuOCCaulph5qjuQTUy1A9yNTzRz2OvLz9EqmXYqrzJmhX4I+AHwAAAAAASFW0iQKxI+gHJBFNzquh5pFSOmnEVGVSHiQ7Df3WDclBva2UiiFa2gHSQZWlVAoAAAAAAACpjjZRIHYE/YAkovzc33//vU2dOtWWLl3q8kkrL/2xxx7r8pwrFzKQiDQn3bx589y8BOqZpfzemqvmlFNOcelZlfMbAAAAAAAACEebKBA75vQDAAAAAAAAAAAAkhyJbgEAAAAAAAAAAIAkR9APAAAAAAAAAAAASHJxn9Nv7Nixdvfdd9uiRYusd+/e9uCDD9puu+0WdfmVK1faDTfcYG+88YabF6pz5842evRoO+yww9zrt9xyi40cOTLkPT169LBp06bFvE2lpaW2YMECa9y4saWlpW1B6QAAQF2nTOlr1qyx9u3bW3p66vanov4EAABiRf1pE+pPAACguutPcQ36vfLKKzZ8+HAbN26c9e/f3wXvBg0aZH/88Ye1bt26zPIbN260gw46yL322muvWYcOHWzOnDnWrFmzkOV22GEH+/jjj4OPMzMrV0xVuDp16rQFJQMAAKkmLy/POnbsaKmK+hMAAKgs6k/UnwAAQPXWn+Ia9Bs1apSde+65NmzYMPdYwb/33nvPnnzySbv22mvLLK/nNbrvq6++sqysLPdcly5dyiynIF/btm2rvF3qYeXtvCZNmlhN9ORaunSptWrVKuV6tFF2yk7ZU0Oqllsoe+qVffXq1a6xxqs/pKqarj/FW6oe355ULn8ql10oP+VP1fKnctlro/zUn1Kj/gQAAGq//hS3oJ9G7U2ePNmuu+664HOqSA4cONAmTZoU8T3vvPOODRgwwC6++GJ7++23XeXz1FNPtWuuucYyMjKCy/35559uiGNOTo5b/q677rKtttoq5m3zUiqowlVTQb+CggK37lT744GyU3bKnhpStdxC2VOz7JLqKZlquv4Ub6l+fKdy+VO57EL5KX+qlj+Vy16b5af+VLfrTwAAoPbrT3EL+i1btsxKSkqsTZs2Ic/rcbT592bOnGmffvqpnXbaafb+++/bjBkz7KKLLrKioiK7+eab3TJKE/r000+7efwWLlzo5vfbe++97ZdffokaAS0sLHQ3f8TUq+TqVt20TuVfrYl1JzrKTtlTTaqWPVXLLZQ99cqeauUFAAAAAABAYopres+qNKppPr9HH33Ujezr27evzZ8/3+6+++5g0O/QQw8NLt+rVy8XBOzcubO9+uqrdvbZZ0dcr0YCKjgYTqks1LOtJsqxatUq1zCaaj0GKTtlp+ypIVXLLZQ99cquSZQBAAAAAACAlA36tWzZ0gXuFi9eHPK8Hkebj69du3ZuLj9/Ks/tttvOFi1a5NKFZmdnl3lPs2bNrHv37m5UYDRKMTp8+PAyuVGVPrSm0ntqCGYqzg1A2Sk7ZU8NqVpuoeypV3alEwcAAAAAAABSNuinAJ1G6n3yySd2zDHHBBsL9fiSSy6J+J4999zTXnzxRbec15g4ffp0FwyMFPCTtWvX2l9//WVnnHFG1G2pV6+eu4XTZ9RUo6UaRWty/YmMslP2VJOqZU/Vcvtza6tDSirR9bm4uNiVuy597+EdjsLVpbICABDvukSi1J+0LZpKRNl/UvFav6Xlr6j+BAAAqo+mUdN1G8mtuupPcU3vqdF1Q4cOtX79+tluu+1mo0ePtnXr1tmwYcPc60OGDLEOHTq49Jty4YUX2pgxY+zyyy+3Sy+91P7880+788477bLLLguu86qrrrIjjzzSpfRcsGCBS/upHXXKKafErZwAgNSrbGmEudJcphJvPj+lu6xoUuFko8wBykRQ18oFAECiULBv1qxZCTNXbl2u19RW+ak/AQBQ89drZUFcuXJlvDcF1aQ66k9xDfoNHjzYzZs3YsQId3DuvPPONn78eGvTpo17fe7cuSE9ypRy88MPP7Qrr7zSzdengKACgNdcc01wmXnz5rkA3/Lly116sb322su+/vprdx8AgNqocClNtHrntG/fPqV6hqvsGumXmZlZZxp3VKb169fbkiVL3GNlFwAAANV/vV24cKHrsKu/+xOh/lQX6zW1VX7qTwAA1A4v4Ne6dWtr0KBBStZZ6opANdaf4hr0E6XyjJbOc8KECWWeGzBggAviRfPyyy9X6/YBAFAZahzRTQE/VbhSSV1tHKtfv777XxUvVaRJVQUAQPVS/UGNHIlUf6qr9ZraKj/1JwAAaj7LlBfwa9GiRbw3B9WguupP8e8+BwBAHat0qWFEI/1Qd3gNkOTIBwCgZupPkp2dHe9NQTWi/gQAQM3xrq+J0mEKiVN/IugHAEANSMUe4XUZ3ycAADWP623dwvcJAEDN43pbt6RVw/dJ0A8AAAAAAAAAAABIcgT9AABAyurSpYuNHj063psBAACQVKhDAQAAJGb9iaAfAACwM88806UQ8OYj7Nq1q1199dVWUFBQLevXenNycmzOnDkhzx9zzDHus2M1YcIEty5NVu33+eef25FHHmnt27d3r7/11lvVst0AACB5lJQGbNJfy+3tqfPd/3pc06hDAQCARFIb9Z8t/TzqTzUrs4bXjzBFJaU2P3+9/Tx3te3btLk1qc9E5QCAxHDIIYfYU0895SYLnjx5sg0dOtRVXv75z39Wy/q1rhEjRtgzzzxj1W3dunXWu3dvO+uss+y4446r9vUDAIDENv6XhTbyP7/ZwlWbG4vaNc2xm4/c3g7ZsV2NfjZ1KAAAkCgy0tPs8pd/sBlL1tb4Z23bupHdf3KfKr2X+lPNYaRfLbvjvd9tv3v+Z5e+8af9tmB1vDcHAICgevXqWdu2ba1Tp06u99PAgQPto48+cq+VlpbaXXfd5Xpf1a9f31VuXnvtteB78/Pz7fTTT3e9nBo0aGDdunVzlTe/Sy65xJ5//nn75Zdfom5DeZ8ze/Zs23///d393NxcV4Hzemgdeuihdvvtt9uxxx4bdd1LlixxPbG0Xq3/hRde2MI9BgAAEiXgd+HzU0ICfrJoVYF7Xq8nch3qtNNOs1atWrnXqUMBAIAtpYDfrwtW1/htSwKL1J9qDiP9alnH3PrB+/PyN8R1WwAAiEaVoq+++so6d+7sHqsSpMrSuHHjXGVKqQwU5FMFa99997WbbrrJfvvtN/vPf/5jbdq0sb/++ss2bAi9zu255542ffp0u/baa+3dd9+N+Lnlfc5ee+1lr7/+uh1//PH2xx9/WJMmTVzlKVaqnC1YsMA+++wzlz7isssuc5UwAACQvJRSSiP8IiWW0nNpZu71g7Zv63q+J2od6oMPPrCWLVvajBkzqEMBAICUQv2pehH0q2WdmjcI3s/LXx/XbQEA1I4jH5xoS9cU1vrntmpcz/5z6V4xL69KUKNGjay4uNgKCwstPT3dxowZ4+7feeed9vHHH9uAAQPcsltvvbVNnDjRHnnkEVfhmjt3ru28887Wt29fy8zMdL2YolWoevXqZV988YXtvffeIa/F8jnNmzd3z7du3dqaNWsWc9lU0VNl8Ntvv7Vdd93VPffEE0/YdtttF/M6AABA4tWfCotLLH99UdTXFfjTCMB+t39k9TIzqr3+VB11qD59+li/fv3c6126dIn4GdShAABAXUL9qeYQ9KtlnXI3B/0Y6QcAqUENVotWV89kxDVJaQsefvhhl5v8vvvuc8E79Wj69ddfbf369XbQQQeFLL9x40ZXyZILL7zQLTtlyhQ7+OCDXYqDPfbYo8xnbL/99jZkyBDX0+rLL78MeU09syr6nKr6/fffXXkUlPT07NmzUpU2AACQvPWnTYHB6MHBRKlDKb0VdSgAAFDXUX+qOQT9almn5puHgOatYKQfAKQC9RhPhs9t2LChbbvttu7+k08+6XKZqyfSjjvu6J577733rEOHDmVysHv5zJXvXOk9lbrgwAMPtIsvvtjuueeeMp8zcuRI6969u7311lshz69du7bCzwEAAKkh1npMRSP9PLkNsmIe6VdZW1qHmjNnjr3//vtuHhvqUAAAIBVQf6o5BP1qWeOcLGtWP8tWbiiyPEb6AUBKqGyKqESgtArXX3+9DR8+3KUlUIVH6ROU3iAa5TxXD6qzzjrLpU34+9//HrHCpUmaNaGy1r/NNtuE9MCq6HOys7Pd/yUlJZUqj3pUKWXE5MmTg6kVlJN95cqVlVoPAABIrPqT5vTb65+f2qJVBRHn9dMsfm2b5tjEaw6olTn9qlqHGjp0qLtRhwIAAKmG+lP1IugXBx2b17eV84tcqpKNxaWWnZke700CAKCME0880VWalMv8qquusiuvvNJKS0vdZMarVq1yqRE0kbEqWCNGjLBddtnFevTo4SpDys1eXq7y6667zh577DGbNWuWDR482D3XuHHjCj9HkzqnpaW59R922GFuEmXlgFcPLaVm8Gi9U6dOdfnXt9pqK7ddhxxyiJ1//vkufYTSLFxxxRWVmoQZAAAkHgXybj5ye7vw+SkuwOcP/HkhPr1eGwG/qtahlPpphx12cHPLJEodKjc319q3b08dCgAA1Iq6UH9qniBtUAT94jSv3y/zV1sgYLZg5Qbr0rJhvDcJAIAyVClRb6h//etfrgKjXlSaBHnmzJkuD7mCfOop5fV+0n2l+FQlRr2sXn755ajrVkXommuuCb7fc9ttt5X7OUq5oNQMysc+bNgwN7Lw6aeftu+//97lg/eod5iokqbX5amnnrJzzjnH9eBq06aN3X777XbTTTfVyL4DAAC155Ad29nDp+9iI//zmy1ctXkeQI3wU8BPrydyHUoNUYlYh1LjmFCHAgAguWzbulHSfU5dqT89nQBtUGmBgEJP8Fu9erU1bdrURXYV1a1ud773mz36xSx3/7mzd7O9u7WyVKGo+ZIlS6x169Zu2G4qoeyUPZXKnqrlFk0CrIqCUgakWg9oVSmUvkAVNfWEqksKCgpcpbNr166Wk5NTq/WGqvj888/t7rvvdqkkFi5caG+++aab2Lo8EyZMcBVVTZqt9Bc33nijnXnmmTF/ZiLuh+qUyue1VC9/KpddKD/lr43yl3edrQyl+vx21gpbsqbAWjfOsd26Nq/yCL+6XK+prfInW/0pHtgPAICqinadVX2oNjMc1Pbn1XUF1VB/Sr2/WhJAx9zNjcB5K5jXDwAAVK9169a5SbDHjh0b0/KqUB5++OGup5pSUijthHqkffjhhzW+rQAAVBc1OA3YpoUdvXMH9z8NUAAAINXUdv2H+lbiIb1nHHRq3iB4Py9/fVy3BQAA1D2HHnqou8Vq3LhxrhfZvffe6x4rF/7EiRPtvvvus0GDBtXglgIAAAAAAKC6MNIvDjqFjPQj6AcAAOJr0qRJNnDgwJDnFOzT8wAAAAAAAEgOjPSLgw7NfEG/fNJ7AgCA+Fq0aJGbWNpPj5UvfsOGDRHnpywsLHQ3j5b15n/Sra5RmTS/UV0sWyxSufypXHah/JS/NsrvfY53SxTetiTSNiVT+b3vM1LdIFV/UwAAADWNoF8c1MvKsFYNs2zpuiKbx0g/AACQhO666y4bOXJkmeeXLl3qJp6ua9Q4qcmy1XiZnp56yTJSufypXHah/JS/NspfVFTkPqu4uNjdEoHKXFJS4u6npaXeXDXVUX59l/pely9fbllZWSGvrVmzplq2EwAAAKEI+sVJu6bZLui3fN1GW1dYbA3r8VUAAID4aNu2rS1evDjkOT1u0qRJxFF+ct1119nw4cNDRvp16tTJWrVq5d5X16jRUo2eKl+qNvynavlTuexC+Sl/bZRfnUUUBMrMzHS3RBIerEo1W1J+fZc6blq0aGE5OTkhr4U/BgAAQPVIrNp0CmnfpJ79tGCduz8vf4P1aNs43psEAABS1IABA+z9998Pee6jjz5yz0dTr149dwunxr262jCuhu+6XL6KpHL5U7nsQvkpf02XX+vW53i3RBnp5m1LomxTspXf+z4jHT+p+nsCAACoadSy4qR9082NZHmk+AQAANVo7dq1NnXqVHeTWbNmuftz584NjtIbMmRIcPkLLrjAZs6caVdffbVNmzbNHnroIXv11VftyiuvjFsZAAAAAAAAUDkE/eKkfZPs4P28fIJ+AACg+nz//ffWp08fdxOl4dT9ESNGuMcLFy4MBgCla9eu9t5777nRfb1797Z7773XHn/8cRs0aFDcygAAAAAAAIDKIegXJ+2a+Ef6bYjrtgAAUJHZs2e79EzeyLG65Omnn7ZmzZpZXbLffvu5tFzhN5VV9P+ECRPKvOeHH36wwsJC++uvv+zMM8+M09YDAFB3UIcCAACoHOpPW4agX5y0b8pIPwBA4lCAxz+XTosWLeyQQw6xn376yb3eqVMnNzpsxx13jKkCVlJSYv/4xz+sZ8+eVr9+fWvevLn179/fjR4T/2dFut1yyy3Bz8jIyLD58+eHrF/bkpmZ6V7Xcp7LLrvM+vbt6+aa23nnnWtwjwEAgERRvHKpFS6YGfWm12sKdSgAAJBIAqWlCf951J9qVmYNrx8RBEqKrVXJKstN32j5pdnM6QcASAiqYD311FPu/qJFi+zGG2+0I444wqWBVKWnbdu2Ma9r5MiR9sgjj9iYMWOsX79+tnr1apdyMj8/P1hh8rzyyisu7eQff/wRfK5Ro0a2bNkyd79Dhw727LPPunnoPM8884x73p+i0nPWWWfZN998E6wsAgCAuksBvfmjLzcrLoq+UGaWdbjifsts1qpGtoE6FAAASBRp6em27N/3W9GS0MBVTchq3cFannh5ld5L/anmEPSrZWt/+J8tf2OsWSBgRzXY155Z29Xm5W9wKbcUKQYAIF7UM8mrVOn/a6+91vbee29bunSprVu3zs37pvSPsfReeuedd+yiiy6yE088Mfic5orz+CtvTZs2ddfA8AqdV+EaOnSoqwj6K1x6rOdvu+22kPc88MAD7n9tc7QKl1IpqIKn9WvOur322qvC8gAAgMRUsn5N+QE/KS5yy9VU0I86FAAASCQK+G1cOMsSGfWnmkN6z1qW0aipC/hJ1+xNc/mtLSy2lesr+CMFAIBatHbtWnv++edt2223dWkWKkuVp08//dRVfLbUUUcd5XpnTZw40T3W/3p85JFHVnpd6n119tln2yWXXOLSQuy///52++23b/E2AgAACHUoAACAyqH+VL0Y6VfLMnNbB+93TF8bMq9fbsPN8/wBAOqW1V/+x1Z/+W6Fy2W372qtT7825Lklz//DNi6ouIdWkz2PsCZ7Vr4S4nn33XddSgNRr6p27dq559LTK99HaNSoUXbCCSe4itcOO+xge+yxhx199NF26KGHVnpdWVlZdvrpp9uTTz7pekTpfz3W85V1//33uxQSV199tXvcvXt3++qrr2z8+PGVXhcAAIh//UnTZ8RiyTN3WFpGZrXXn4Q6FAAAQOVQf6o5jPSrZZlNWwbvtyhdE7yft2LTqD8AQN1UWrDBSlavqPi2bnWZ9+q5WN6rz9gS6nGknke6ffvtty7tgCpIc+bMqfS6tt9+e/vll1/s66+/dvnNlyxZ4npFnXPOOVXaNq3j3//+t8vzrv/1uCp+//13N5mz34ABA6q0LgAAEP/6U2mEulPEdUWpT21p/UmoQwEAAFQO9ac6HPQbO3asdenSxXJyctwO0BdcnpUrV9rFF1/sIr/K+6ro6Pvvv79F66xNaVnZltE4191vXLgyZKQfAKDuSs+pbxlNmld8a9ikzHv1XCzv1WdsiYYNG7pUCrrtuuuu9vjjj7veVo899ljVypye7tZzxRVX2BtvvOHymD/xxBM2a1bl88rvtNNO1rNnTzvllFNsu+22sx133LFK2wQAAOpW/Sk9Qt0p4rqi1Ke2tP4k1KEAAAAqh/pTHU3v+corr9jw4cNt3LhxLjg3evRoF9H9448/rHXrzWkwPRs3brSDDjrIvfbaa69Zhw4dXOS3WbNmVV5nPGTktraSNfmWVbjG6lmxFVqm5a0g6AcAdZnSRlU1dVR4us/aoomNVWnasKF6RqOr55WoElcV6lmliZkffvjhKm+DKmvKqe6nnmAAACA560+FC2baooeuqXBdrYfeYPXab221gToUAABA5VB/qiNBP+VaPffcc23YsGHusQJ17733nsuTeu21ZRs49fyKFStc3lMvh6pG9G3JOuMhs1kr2zj3D3e/ra21OdbM8vJJ7wkAiK/CwkKXukA0SfGYMWPcZMrlTVasTjWeQCBgxcXF1rt3bzv11FNtzz33dHnUlVNdPauuu+46N0JfvaWqQtf3E088MaSzT7gZM2a4bVY5VFFUmgivspednW2XXXaZ26577rnH5Xf/8MMPmYsGAADEtQ7l0Rw06lGeKHUo1et69erlsixRhwIAANWprtafEqENKm5BP43amzx5stv5HkVyBw4caJMmTYr4nnfeecflPFV6z7fffttatWrlGhWvueYay8jIqNI64yEzd/OIw86Z621OcTObx0g/AECcqeKh9NnSuHFjVzFS7vL99tvPZs+eHfE9J598cpnn5s6d60bZv/TSS3bXXXfZqlWrXKXrgAMOsFtuucUyM6tW/dD7WrbcPDduJMrX/r///S/4uE+fPu5/VfjUUWj33Xd3qSJuvvlmGzFihKsj3HjjjXbbbbdVaZsAAEB8ZTRobJaZZVZcFH2hzKxNyyV4HSovLy9h6lC77LKL+3/mzJnWtWvXlKhDff7553b33Xe7dqWFCxfam2++acccc0y575kwYYLLNvXrr79ap06d3D4588wza22bAQCIJKt1h4T/nLpYf+qTIG1QaQF1y4+DBQsWuPScGrXnn7zw6quvdjsqfNij6IvXF37aaae5oZWKpOp/RUy146qyTi+qrJtn9erVrrKmCHOTJrHND1AZa77/xFa+86i7/3yDfe2x1V0tOyPNfhs5yNLT06wuKy0ttaVLl7qArQKyqYSyU/ZUKnuqllvWr1/vrlXbbLONm1s21RQVFQVH49clBQUFwUpb+PeqekNubq6rWNZEvSFZaD80bdq0zu4Hndc0GbjSxafaeS3Vy5/KZRfKT/lro/zedVbBparUn4pXLrWS9Wuivq6AnzLuVIaXwUANPko3lWqqo/zlfa+JWG/44IMP7Msvv7S+ffvacccdV2HQT2XTHD8XXHCBa/T75JNP3DxCyjalxsdYJOJ+AAAkh2jX2UBpqaXVYr21tj+vriuohvpTXNN7VuUPDv2x8eijj7qRfaqIzZ8/3/XEUtCvqhQBHjlyZJnn1WCtnVzdim1zY+hWGWvd/xtLAvbb7PnWulG21WX6DnVQ6g+IVPujmbJT9lQqe6qWWzTqXOVX8KuqvYmSlb7vkpISd7+uNY6p0Uvf6/Lly8sENdesid7ICAAAap4CepUN6gHhDj30UHeLlaaTUYPcvffeG5y3Z+LEiXbffffFHPQDAKC61XYAjoBf4olba6SGRipwt3jx4pDn9VjDLyPRcE81tOl9HlWqlDNVjaxVWacoHajSMYSP9NMIlZroaVXcqIEtzbzCWnbpZjM+X2z29Vz3/Ib0Bta6dXOry9RgqobgVBz9Q9kpeyqVPVXL7Y3003VE16tUC/p56uJIP32XOpZbtGhRpqdVKo7oBAAASHWaRkZpuvwU7NNoPwAAgHiJW2ukJjLUSD2lP/DSJaiRWI8vueSSiO/RpIcvvviiW85rRJ4+fboLBmp9Utl1iial1i2cPqMmGqszGzSyjPbbWFazltapxaaRfjJ/ZYH1T4HGcQUCamrfJjrKTtlTSaqW21/eujbaLZaRfl6Z61rZVZ5ox3SqHeMAAAAw1wG9TZs2Ic/psToAbtiwwerXrx/T9DIAAADVKa6tVBpdp4kMn3nmGfv999/twgsvtHXr1tmwYcPc60OGDHGj8Dx6fcWKFXb55Ze7YJ/ypN9555128cUXx7zORNOpeYPg/bwVG+K6LQAAAAAAAKgZml5Gc/F4N2WZAgAAqE5xzTs2ePBgN2/eiBEjXA+pnXfe2caPHx/sKTV37tyQ3vOqDH344Yd25ZVXWq9evaxDhw4uAHjNNdfEvM5E0ynXF/TLXx/XbQEAAAAAAEDFNI1MpOllNE1MpFF+5U0vAwAAUF3iPtmQ0m5GS705YcKEMs8NGDDAvv766yqvM1GULptna2ZNsRbLl1hby7FF1tjyVhD0A4C6lOoSdYfShQMAgJpF/aluqev1J7VPvf/++yHPffTRR+75yk4vAwBAVdX1622qKa2G7zPuQb9UVTrzJ1v57Qfufq+cg21RQWObl096TwBIdllZWe7/ZcuWWatWrerc3HYVNdQVFxdbZmZmnSm3yrRx40aXRUDZB7w5hAEAQPXWn1R30PU2UepPdbFeU1vlT9b609q1a23GjBnBx7NmzbKpU6da8+bNbauttnKj9ObPn2/PPvuse/2CCy6wMWPG2NVXX21nnXWWffrpp/bqq6+6qWgAAKhpur7qOrtgwQJXf9LjVKyz1BWBaqw/EfSLk7TGLYL3u9cvtP8WmC1ctcGKSkotKyOuUy0CALZARkaGS+mzfv16mz17tqVaBUU9klQ5qWsVzQYNGrjGHn/acQAAUH31p44dO9q8efMSpv5Ul+s1tVX+ZKs/ff/997b//vsHH3tpOIcOHWpPP/20LVy40E1D4+natasL8GkKmvvvv98dw48//rgNGjQoLtsPAEgtur7qWqTrkwJ/qBsaVEP9iaBfnKQ12Rz065K1zv1fGjBbsHKDdW7RMI5bBgDYUuqN065dOyspKbFUooah5cuXW4sWLZKmcSfWhshU7eUPAEBtadSokXXr1s2KioosEdTVek1tlT8Z60/77bdfuSlmFfiL9J4ffvihhrcMAIDo7U8KEGl0fqq1QdVFGdVUfyLoFydpTZoH77e1TUE/yVtB0A8A6sqF2kv1mUqNQypzTk5OSjaOAQCALa8/6ZYIUr1ek+rlBwAgWShApGt2qrVBITpqbvHSsJlZ+qY/ZnKLVwWfzstfH8eNAgAAAAAAAAAAQDIi6BcnaenpltG0pbtff0N+8Pm8FQT9AAAAAAAAAAAAUDkE/eIoM7eV+z+jaIM1skJ3Py9/Q5y3CgAAAAAAAAAAAMmGoF8cZTbbFPSTdrbW/c9IPwAAAAAAAAAAAFQWQb84ysxtHbzfs0GB+38ec/oBAAAAAAAAAACgkjIr+wZUn8yWHSyrbWcX/GuwtKnZerNlazfa+o3F1iCbrwYAAAAAAAAAAACxIbIURw126G+Ndhrg7m98ZarZovnu/rz8Dda9TeM4bx0AAAAAAAAAAACSBek9E0Sn3PrB+3OXk+ITAAAAAAAAAAAAsSPolyA6Nm8QvJ/HvH4AAAAAAAAAAACoBIJ+CaJTM430C7j7eSs2xHtzAAAAAAAAAAAAkESY0y/OVn78sq3/9Wtrn7/UmtpxtspyGOkHAAAAAAAAAACASmGkX5yVrFttRUvnmxVvtI7pa91zeSsI+gEAAAAAAAAAACB2BP3iLDO3dfD+dg03uv/n5W+wQGBTqk8AAAAAAAAAAACgIgT9Eijo1y1n01x+awuLbeX6ojhuFQAAAAAAAAAAAJIJQb84y8xtFbzfKWNzWk/m9QMAAAAAAAAAAECsCPol0Ei/VqWrg/fzVmwa9QcAAAAAAAAAAABUhKBfnKU3aGJpWfXc/SZFq4LPM9IPAAAAAAAAAAAAsSLoF2dpaWnB0X711q+wNAu4+3krCPoBAAAAAAAAAAAgNgT9Emhev7SSYsu1TWk98/JJ7wkAAAAAAAAAAIDYEPRLsHn9umRuGuE3j5F+AAAAAAAAAAAAiFFmrAui5jTYcQ/Lar2VC/4Vv73YbFmRzcvfYKWlAUtPT4v35gEAAAAAAAAAACDBEfRLADldtnM3adnyO7NlS2xjSaktWVNobZvmxHvzAAAAAAAAAAAAkOBI75lgOuXWD97PyyfFJwAAAAAAAAAAACpG0C/BdGreIHg/j3n9AAAAAAAAAAAAEAPSeyaI4pXLrDh/sW23Zm7wubwVG+K6TQAAAAAAAAAAAEgOBP0SxJLn/2FFi+ZYh/QMS7fTrNTSSe8JAAAAAAAAAACAmJDeM0Fk5rZ2/6eVllhL2xTsI70nAACoqrFjx1qXLl0sJyfH+vfvb99++23UZYuKiuzWW2+1bbbZxi3fu3dvGz9+fK1uLwAAAAAAALYMQb8EC/rJtvUK3P/z8knvCQAAKu+VV16x4cOH280332xTpkxxQbxBgwbZkiVLIi5/44032iOPPGIPPvig/fbbb3bBBRfYscceaz/88EOtbzsAAAAAAACSOOhXmZ7oTz/9tKWlpYXc9D6/M888s8wyhxxyiCWyzGatgve3a1jo/l+4aoMVlZTGcasAAEAyGjVqlJ177rk2bNgw23777W3cuHHWoEEDe/LJJyMu/9xzz9n1119vhx12mG299dZ24YUXuvv33ntvrW87AAAAAAAAknROP68nuhqjFPAbPXq064n+xx9/WOvWm0e/+TVp0sS97lFQL5yCfE899VTwcb169SxZRvp1zd40wq80YLZg5Qbr3KJhHLcMAAAkk40bN9rkyZPtuuuuCz6Xnp5uAwcOtEmTJkV8T2FhYZlOVPXr17eJEydG/Ry9RzfP6tWr3f+lpaXuVteoTIFAoE6WLRapXP5ULrtQfsqfquVP5bLXRvlTdb8CAADU+aCfvye6KPj33nvvuZ7o1157bcT3KMjXtm3bcterIF9FyyRq0K992trg/bwVBP0AAEDsli1bZiUlJdamTZuQ5/V42rRpEd+jDleqk+2zzz5uXr9PPvnE3njjDbeeaO666y4bOXJkmeeXLl1qBQWbUpXXJWqcXLVqlWsAVRA11aRy+VO57EL5KX+qlj+Vy14b5V+zZk21rxMAAABxDvpVpSe6rF271jp37uwqobvssovdeeedtsMOO4QsM2HCBDdSMDc31w444AC7/fbbrUWLFgnRUz1Sj7n0pi2D91uUbPp8mbtinZWWNre6IpV7S1J2yp5KUrXcQtlTr+x1obz333+/64TVs2dP17lKgT91yIqWDlRUf1O2Bn/9qVOnTtaqVSuXlaEufs/aNypfqjb+pmr5U7nsQvkpf6qWP5XLXhvlD88wAAAAgDoQ9KtKT/QePXq4BqhevXq5Xmf33HOP7bHHHvbrr79ax44dg6k9jzvuOOvatav99ddfbo6aQw891AUSMzIy4t5TPWqPuZyGZgXrrP6G5cGn/pi3zJZ0TuzUpJWRyr0lKTtlT6Wyp2q5hbKnXtkTrad6y5YtXX1n8eLFIc/rcbQsCGrQe+utt1y9Z/ny5da+fXuXcUHz+5WXVSFS+nR993X1+1fjZ10uX0VSufypXHah/JQ/VcufymWv6fKn6j4FAACo8+k9K2vAgAHu5lHAb7vttrNHHnnEbrvtNvfcySefHHx9p512cgFC9VjX6L8DDzww7j3Vo/WYW9S8jRUtmGnZBastw0qtxNJteWFa1LkNk1Eq95ak7JQ9lcqequUWyp56ZU+0nurZ2dnWt29fl6LzmGOOCX43enzJJZdUWJYOHTpYUVGRvf7663bSSSfV0lYDAAAAAAAgqYN+VemJHi4rK8v69OljM2bMiLqMeqnrs7RMpKBfPHqqR+oxl5Xb2ooWzbHMpi2t6dICW2ENbF7+hjrXcJrKvSUpO2VPJalabqHsqVX2RCyrOjMNHTrU+vXrZ7vttpuNHj3a1q1bF5xDeciQIS64p2wH8s0339j8+fNt5513dv/fcsstLlB49dVXx7kkAAAAAAAAiFV6ovRE93g90f2j+cqj9KA///yztWvXLuoy8+bNc6mqylsmEbQ49kLb6pYXrOPfxlhm41z33Lz89fHeLAAAkGQGDx7sUqCPGDHCBfKmTp1q48ePD6ZUnzt3ri1cuDC4vNJ63njjjbb99tvbscce6wKCEydOtGbNmsWxFAAAAAAAAEiq9J6V7Yl+66232u67727bbrutrVy50u6++26bM2eOnXPOOe71tWvXuvn5jj/+eDdaUHP6qZe6lh80aJAlsvScBsH7nZo3sCVrCm3Z2o22fmOxNciO+1cFAACSiFJ5RkvnqZTnfvvuu6/99ttvtbRlAAAAAAAAqAmZidATfenSpa4n+qJFi1xv9PCe6P60Wfn5+Xbuuee6ZXNzc91Iwa+++sr1TBelC/3pp5/smWeecUHB9u3b28EHH+zm+4uUwjNRdcqtb5Pn5Lv7SvHZvU3jeG8SAAAAAAAAAAAAElTcg36V7Yl+3333uVs09evXtw8//NCSnUb6efJWrCfoBwAAAAAAAAAAgMQO+mGTQCBgK//7ghXnL7F91pTag7ZdMOgHAAAAAAAAAAAAREPQL4GkpaXZ2h8mWOnaVdaiQVMzL+iXvyHemwYAAAAAAAAAAIAEtnmyPCSEzGat3f8Z61dZthW7+4z0AwAAAAAAAAAAQHkI+iWYzNxNQT9pl74p2MdIPwAAAAAAAAAAAJSHoF+CycxtFby/Q6NC9/+8FevdfH8AAAAAAAAAAABAJAT9EnikX/ecTUG/NYXFtmpDURy3CgAAAAAAAAAAAImMoF+CzuknnTM3z+WXt4IUnwAAAAAAAAAAAIiMoF8Cj/RrY2uC9/PyNwcAAQAAAAAAAAAAAD+Cfgkms1lLs7Q0d79Z0arg83krCPoBAAAAAAAAAAAgMoJ+CSYtM8syGue6+/UL8oPPM9IPAAAAAAAAAAAA0WRGfQVx07D33hYoKrQN9ZubfRRQKJA5/QAAAAAAAAAAABAVQb8ElDvodPd/IBCwnAnjraColJF+AAAAAAAAAAAAiIr0ngksLS3NOuY2cPfn5W+w0lKN+gMAAAAAAAAAAABCEfRLcJ1y67v/NxaX2tK1hfHeHAAAAAAAAAAAACQggn4JSqk9S9avsZ6NioPP5a0gxScAAAAAAEBNGDt2rHXp0sVycnKsf//+9u2335a7/OjRo61Hjx5Wv35969Spk1155ZVWUFBQa9sLAAAQjqBfAipevdzybhti8+48y/Zf+FHweeb1AwAAAAAAqH6vvPKKDR8+3G6++WabMmWK9e7d2wYNGmRLliyJuPyLL75o1157rVv+999/tyeeeMKt4/rrr6/1bQcAAPAQ9EtAGQ2bWqBoUyrPJkWrgs/nrdgQx60CAAAAAACom0aNGmXnnnuuDRs2zLbffnsbN26cNWjQwJ588smIy3/11Ve255572qmnnupGBx588MF2yimnVDg6EAAAoCYR9EtAaRmZltG0pbufs3558HnSewIAAAAAAFSvjRs32uTJk23gwIHB59LT093jSZMmRXzPHnvs4d7jBflmzpxp77//vh122GFRP6ewsNBWr14dcgMAAKhOmdW6NlSbzNzWVrJyqaUVrreGttHWWTbpPQEAAAAAAKrZsmXLrKSkxNq0aRPyvB5PmzYt4ns0wk/v22uvvSwQCFhxcbFdcMEF5ab3vOuuu2zkyJHVvv0AAAAeRvolqMxmrYL3t83ZNAk06T0BAAAAAADib8KECXbnnXfaQw895OYAfOONN+y9996z2267Lep7rrvuOlu1alXwlpeXV6vbDAAA6j5G+iXwSD/PDg0L7ccCs4WrNlhRSallZRCrBQAAAAAAqA4tW7a0jIwMW7x4ccjzety2bduI77npppvsjDPOsHPOOcc93mmnnWzdunV23nnn2Q033ODSg4arV6+euwEAANQUokdJEPTbpt6mkX6lAbOFKzfdBwAAAAAAwJbLzs62vn372ieffBJ8rrS01D0eMGBAxPesX7++TGBPgUNRuk8AAIB4YKRfEgT9OmasC97XvH5btWgQp60CAAAAAACoe4YPH25Dhw61fv362W677WajR492I/eGDRvmXh8yZIh16NDBzcsnRx55pI0aNcr69Olj/fv3txkzZrjRf3reC/4BAADUNoJ+STCnX8vS1cH7eSvWx2mLAAAAAAAA6qbBgwfb0qVLbcSIEbZo0SLbeeedbfz48damTRv3+ty5c0NG9t14442Wlpbm/p8/f761atXKBfzuuOOOOJYCAACkOoJ+CSqjSa7yQpiVlFjjjatCRvoBAAAAAACgel1yySXuFsmECRNCHmdmZtrNN9/sbgAAAImCoF+CSkvPsDZDb7SMRs1sTlF9swe/ds/nrdgQ700DAAAAAAAAAABAgiHol8Bytt7R/d+xqCT4HCP9AAAAAAAAAAAAEG5zMnIkrJysDGvduJ67z0g/AAAAAAAAAAAAhCPolyQ6NW/g/l+2ttDWbyyO9+YAAAAAAAAAAAAggZDeM4GVrF1lG2b8aMX5S2yvTLPJVt89Py9/g3Vv0zjemwcAAAAAAAAAAIAEQdAvgRWvWGTLX3vQ3e/Vrr+Zbefu561YT9APAAAAAAAAAAAAiZXec+zYsdalSxfLycmx/v3727fffht12aefftrS0tJCbnqfXyAQsBEjRli7du2sfv36NnDgQPvzzz8t2WTktg7eb1G6OnhfQT8AAAAAAAAAAAAgYYJ+r7zyig0fPtxuvvlmmzJlivXu3dsGDRpkS5YsifqeJk2a2MKFC4O3OXPmhLz+r3/9yx544AEbN26cffPNN9awYUO3zoKCAksmGY2aWVpmlrvfqCA/+Hxe/oY4bhUAAAAAAAAAAAASTdyDfqNGjbJzzz3Xhg0bZttvv70L1DVo0MCefPLJqO/R6L62bdsGb23atAkZ5Td69Gi78cYb7eijj7ZevXrZs88+awsWLLC33nrLkonKmdGslbuftW6FSufuM9IPAAAAAAAAAAAACRP027hxo02ePNml3wxuUHq6ezxp0qSo71u7dq117tzZOnXq5AJ7v/76a/C1WbNm2aJFi0LW2bRpU5c2tLx1JqpML8Vn8UZrkV7o7jLSDwAAAAAAAAAAAH6ZFkfLli2zkpKSkJF6osfTpk2L+J4ePXq4UYAawbdq1Sq75557bI899nCBv44dO7qAn7eO8HV6r4UrLCx0N8/q1ZvmzystLXW36qZ1akRiLOv2RvrJTo022oTVOW6kn/abRgImm8qUva6h7JQ9laRquYWyp17ZU628AAAAAAAASExxDfpVxYABA9zNo4DfdtttZ4888ojddtttVVrnXXfdZSNHjizz/NKlS2tkHkA1DipgqYZRjWwsT3FWg+D9bbPX2QRrYmsLi21G3kJrmpN0X1+lyl7XUHbKnkplT9VyC2VPvbKvWbNmi9ehDkeNGjUqs9/UyWfdunVuPmMAAAAAAACgPHGNGrVs2dIyMjJs8eLFIc/rsebqi0VWVpb16dPHZsyY4R5779M62rVrF7LOnXfeOeI6rrvuOhs+fHhIw5tSh7Zq1apGGtnUKKpRelp/RY2i6zt2teX/f3/b+huDzxdkNLRurZtasqlM2esayk7ZU6nsqVpuoeypV/acnJwtev+bb75p11xzjU2dOtXNa+ynzke77rqry2xw5JFHbuGWAgAAAAAAoC6La9AvOzvb+vbta5988okdc8wxwQZDPb7kkktiWod6wP/888922GGHucddu3Z1gT+twwvyKYj3zTff2IUXXhhxHfXq1XO3cGqwrKlGSzWKxrL+rOab05S2S1sXvD9/ZYH17pRrySjWstdFlJ2yp5JULbdQ9tQq+5aW9eGHH7arr766TMBPGjZs6AKCY8aMIegHAAAAAACAcsW9RU4j7B577DF75pln7Pfff3eBOaWxGjZsmHt9yJAhbiSe59Zbb7X//ve/NnPmTJsyZYqdfvrpNmfOHDvnnHOCjY1XXHGF3X777fbOO++4gKDW0b59+2BgMZlk5rZ28/rV67qDZbXcPHJR8/oBAIDk98svv9h+++0X9fV99tnH1WcAAAAAAACA8sR9UrjBgwe7ufNGjBhhixYtcqPzxo8fb23abBrhNnfu3JAe9Pn5+Xbuuee6ZXNzc91Iwa+++sq233774DLqLa/A4XnnnWcrV660vfbay61zS9NvxUNGwybW8aqH3P35c/LNpnzl7uflE/QDAKAuUN2muLg46utFRUVuGQAAAAAAACChg36iVJ7R0nlOmDAh5PF9993nbuXRaD+NCNStLunUvH7wft6KDXHdFgAAUD26dOli33//vfXs2TPi63qtc+fOtb5dAAAAAAAASC5xT++J2LVqVM9ysjZ9ZYz0AwCgbjjuuOPshhtusMWLF5d5TZkNbrzxRjv++OPjsm0AAAAAAABIHgkx0g+x0QjGjrkNbMaStTYvf4OVlgYsPT0t3psFAAC2wLXXXmtvv/22devWzc1V3KNHD/f8tGnT7IUXXrBOnTq5ZQAAAAAAAIDyMNIvCWz4Y4oteuQGm/ePc+2wzFnuuY3FpbZ0bWG8Nw0AAGyhxo0b25dffukCfq+88opdeeWV7qb7em7ixIlumcoaO3asSx2qOY379+9v3377bbnLjx492gUc69ev7wKN2oaCgoItKBkAAAAAAABqEyP9kkCgpMgK86a7+12arlOiT3c/b8V6a9MkJ85bBwAAtlTTpk3toYcecoG6ZcuWWSAQsFatWrlR/lWhgOHw4cNt3LhxLuCngN6gQYPsjz/+sNatW5dZ/sUXX3SjCZ988knbY489bPr06XbmmWe6zx81alQ1lBAAAAAAAAA1jZF+SSCz2ebGuTa2Nnifef0AAKhbFGRTsE+BuaoG/ESBunPPPdeGDRtm22+/vQv+NWjQwAX1Ivnqq69szz33tFNPPdWNDjz44IPtlFNOqXB0IAAAAAAAABIHI/2SQGbu5qBfbtGq4P28FRvitEUAAKC65ObmRgzwafRf9+7d7aqrrrKDDjoo5vVt3LjRJk+ebNddd13wufT0dBs4cKBNmjQp4ns0uu/55593Qb7ddtvNZs6cae+//76dccYZUT+nsLDQ3TyrV692/5eWlrpbXaMyaQRmXSxbLFK5/KlcdqH8lD9Vy5/KZa+N8qfqfgUAAKhpBP2SQHr9hpaW08ACBeut/ob84PNK7wkAAJKbUm9GsnLlShe8O+KII+y1116zI488Mqb1KT1oSUmJtWnTJuR5PZ42bVrE92iEn9631157uQa+4uJiu+CCC+z666+P+jl33XWXjRw5sszzS5curZNzAapxctWqVW7/KIiaalK5/KlcdqH8lD9Vy5/KZa+N8q9Zs6ba1wkAAACCfkk12q9o4WxLX7vCMqzUSiyd9J4AANQBQ4cOLff1nXfe2QXYYg36VcWECRPszjvvdPMKag7AGTNm2OWXX2633Xab3XTTTRHfo5GEmjfQP9KvU6dOLj1pkyZNrC42fnrpV1O18TdVy5/KZRfKT/lTtfypXPbaKH9OTk61rxMAAAAE/ZJGZrNWLuhngVLrUq/Q/iqsT3pPAABSgEb63X777TEv37JlS8vIyLDFixeHPK/Hbdu2jfgeBfaUyvOcc85xj3faaSdbt26dnXfeeXbDDTdEbOyrV6+eu4XTsnW1cVSNn3W5fBVJ5fKnctmF8lP+VC1/Kpe9psufqvsUAACgplHLSsJ5/XZqXOT+X7hqgxWVkAcfAIC6TPPmZWdnx7y8lu3bt6998sknIb319XjAgAER37N+/foyjW8KHIrSegEAAAAAACDxMdIvSWTmbp6Xp1uO5slpYqUBs4UrC2yrFg3ium0AAKDmPPHEEy7FZ2Uo7abShvbr18922203N2+gRu4NGzbMvT5kyBDr0KGDSxsqSh06atQo69OnTzC9p0b/6Xkv+AcAAAAAAIDERtAvSWTmtgre3ypzXfC+5vUj6AcAQPLyz4vnt2rVKpsyZYpNnz7dPv/880qtc/DgwbZ06VIbMWKELVq0yAUNx48fb23abOpENHfu3JCRfTfeeKNL4aX/58+f7+bvUcDvjjvu2MLSAQAAAAAAoLYQ9EsS2e26WrNBp7u5/TYszjabvWmenrwV6+O9aQAAYAv88MMPEZ9v0qSJHXTQQfbGG29Y165dK73eSy65xN0imTBhQsjjzMxMu/nmm90NAAAAAAAAyYmgX5LIbNrCmu59tLvfKmuJmf1/0C+foB8AAMnss88+i/cmAAAAAAAAoA7YnNcJSaNT8/rB+3krNsR1WwAAQM0JBAL2wQcf2AknnBDvTQEAAAAAAECCI+iXhDrmbp7Dj5F+AADUPbNmzbKbbrrJttpqKzv22GOtoKAg3psEAAAAAACABEd6zyRSWrDeivMXW2n+EuvaKGCz1qYx0g8AgDqisLDQXnvtNXviiSds4sSJVlJSYvfcc4+dffbZbn4/AAAAAAAAoDyM9Esiq/73hi0ce7UtffEe699wjXtu2dpC27CxJN6bBgAAqmjy5Ml20UUXWdu2bW306NF2zDHHWF5enqWnp9ugQYMI+AEAAAAAACAmjPRLIpnNWgXvb1NPab42NQLOy19v3do0juOWAQCAqurfv79deuml9vXXX1uPHj3ivTkAAAAAAABIUoz0SyKZua2D9ztlrAveZ14/AACS14EHHuhSet566602fvx4CwQC8d4kAAAAAAAAJCGCfkka9GtVujp4n3n9AABIXh9++KH9+uuvbpTfhRdeaO3atbPLL7/cvZaWlhbvzQMAAEhI+fn59uCDD9rq1ZvbRzyrVq2K+hoAAEBdRtAviWQ0axm833jjquD9vBWM9AMAIJl16tTJRowYYbNmzbLnnnvOli5dapmZmXb00Ufb9ddfb1OmTIn3JgIAACSUMWPG2Oeffx5x/uOmTZvaF1984QJ/AAAAqYSgXxJJz6pnGY2aufv11i8PPk96TwAA6o6DDjrIXnzxRVuwYIGb6++DDz6wXXfdNd6bBQAAkFBef/11u+CCC6K+fv7559trr71Wq9sEAAAQbwT9kjXF57pVVj+9xN0lvScAAHXLvHnzXA91Bf1++OEH++677+K9SQAAAAnlr7/+sm7dukV9Xa9pGQAAgFRC0C/JZOS2Ct7fsVGR+5+RfgAA1C3bb7+9zZ49O/h4l112iev2AAAAJJqMjAyXGSEavZaeTrMXAABILdR+knWknxoEG250/68pKLZV6zcFAAEAQPILBALx3gQAAICE1qdPH3vrrbeivv7mm2+6ZQAAAFJJZrw3AJWT2WxT0C+9QWNr33Dz8xrt17RB0/htGAAAAAAAQC255JJL7OSTT7aOHTvahRde6Eb+SUlJiT300EN23333uXmSAQAAUglBvyTTsPde1rDXnpZer75t/ORPsxnT3fN5K9bbjh0I+gEAUBdcf/311rx583hvBgAAQMI6/vjj7eqrr7bLLrvMbrjhBtt6663d8zNnzrS1a9fa3//+dzvhhBPivZkAAAC1iqBfkknPzgne79S8QfA+8/oBAJC8Vq9ebY0aNQrOO3PdddcFe6qvW7fOmjRpEuctBAAASDx33HGHHX300fbCCy/YjBkzXIr0fffd10499VTbbbfd4r15AAAAtY6gXxLr1Lx+8H7eig1x3RYAAFA1mm/mmmuusalTp1qDBps79EhBQYHtuuuuds8999iRRx4Zt20EAABIVAruEeADAADYhKBfEuuUy0g/AACS3cMPP+xSU4UH/KRhw4YuIDhmzBiCfgAAAD7vvPNOxOebNm1q3bt3t3bt2tX6NgEAAMTbphxScTZ27Fjr0qWL5eTkWP/+/e3bb7+N6X0vv/yypaWl2THHHBPy/Jlnnume998OOeSQGtr62rd26he2/K1xFnj9bmuaWRKc0w8AACSfX375xfbbb7+or++zzz72888/1+o2AQAAJDq1BUW67b///taxY0c77bTTbP162koAAEBqiXvQ75VXXrHhw4fbzTffbFOmTLHevXvboEGDbMmSJeW+b/bs2XbVVVfZ3nvvHfF1BfkWLlwYvL300ktWVxTM+NHWfv+JFfz1k/VuUuSem5e/weWuBwAAySU/P9+Ki4ujvl5UVOSWAQAAwGalpaURb6o3ffTRR66N6fbbb4/3ZgIAAKRW0G/UqFF27rnn2rBhw2z77be3cePGufRWTz75ZNT3lJSUuB5bI0eOtK233jriMvXq1bO2bdsGb7m5uVZXZOa2Ct7v2WCj+7+wuNSWrimM41YBAICqULaD77//Purreq1z5861uk0AAADJSuk9DzjgALvvvvvsjTfeiPfmAAAApE7Qb+PGjTZ58mQbOHDg5g1KT3ePJ02aFPV9t956q7Vu3drOPvvsqMtMmDDBLdOjRw+78MILbfny5VZXZOa2Dt7fOntzqgrm9QMAIPkcd9xxdsMNN9jixYvLvLZo0SK78cYb7fjjj4/LtgEAACSrnj172rx58+K9GQAAALUq0+Jo2bJlbtRemzZtQp7X42nTpkV8z8SJE+2JJ56wqVOnRl2vUnuqAa1r1672119/2fXXX2+HHnqoCyRmZGSUWb6wsNDdPKtXr3b/e6khqpvWqVScVV13etOWwfvtbG3w/pzl66xPp2aWyLa07MmMslP2VJKq5RbKnnpl39LyXnvttfb2229bt27d7PTTT3cdlkR1oRdeeME6derklgEAAEDsZs6cae3bt4/3ZgAAAKRO0K+y1qxZY2eccYY99thj1rLl5sBXuJNPPjl4f6eddrJevXrZNtts40b/HXjggWWWv+uuu1yq0HBLly61goICq4nGwVWrVrmGUY1srKxAyebAZeNCjWDc1t2flrfMlrTPskS2pWVPZpSdsqdS2VO13ELZU6/sqp9sicaNG9uXX35p1113nZvr2Ju/r1mzZi4IeMcdd7hlAAAAEBt1FL/qqqvs8MMPr9T7xo4da3fffbfLttC7d2978MEHbbfddou6/MqVK13GBqURXbFihUvJPnr0aDvssMOqoRQAAAC1FPTLy8uztLQ069ixo3v87bff2osvvujm5DvvvPNiXo8Cdxp5F57OSo81D184jdqbPXu2HXnkkWV612dmZtoff/zhgnvhNO+fPmvGjBkRg35qZBs+fHjISD/1qm/VqpU1adLEqpu2WftP669S0K9FC5un95WWWrPizSP98jemu5SmiWxLy57MKDtlT6Wyp2q5hbKnXtlzcnKqZe6Zhx56yDU0KROCAqfaj9qfAAAAKCs3NzdiXWndunVWXFxsBx10UMQO3tGo85XahsaNG2f9+/d3wbtBgwa5tqZIbS2askafoddee+0169Chg82ZM8d13AIAAEiqoN+pp57qgnsadafeT6rk7LDDDi4FlR6PGDEipvVkZ2db37597ZNPPrFjjjkm2GCox5dccknEfOw///xzyHOa50Y97O+//34XqItEOdw1p1+7du0ivl6vXj13C6cGy5pqtFTFtMrrT0+3zKYtrTh/iWWu2zxX4bz8DUnRyLpFZU9ylJ2yp5JULbdQ9tQqe3WWVfWc6dOnu/tK86mMBQAAAChLQblI1Hlb9Sh1TK+MUaNG2bnnnmvDhg1zjxX8e++99+zJJ5+MmGpdz2t031dffWVZWZuyLnXp0qVKZQEAAIhr0O+XX34Jpjd49dVXbccdd3Rpqf773//aBRdcEHPQT9SLaujQodavXz+3TlXa1CvLq2QNGTLE9ZZSCk71pNdn+Xk9qLzn165d63pyHX/88W60oEYHXn311bbtttu6Hlp1RUazVi7oFyhYb+3qldjCwgzLy18f780CAABVoKwJZ599tv32229ulJ8XQFWnKs1lvOuuu8Z7EwEAABKK2pIqoqBc8+bNK1xOo/YmT57sMkH5O3YNHDjQJk2aFPE977zzjg0YMMAuvvhiNz+zsjSok/w111zjsloBAADEQ5W6phcVFQVHxn388cd21FFHBUfiLVy4sFLrGjx4sN1zzz0uULjzzju7vOvjx4+3Nm3auNfnzp1bqXWqYvXTTz+5berevbtrQNNowi+++CLiaL5klZm7ObVErybF7v+FqwqsuGRTulMAAJAcFOhT+vH69evb888/b1OmTHG35557ztVd9JqWAQAAQGzUKf2kk05ynchjofTqJSUlwbYojx4ro1UkM2fOdGk99b7333/fbrrpJrv33nvt9ttvj/o5hYWFbkoZ/w0AACDuI/3U61xpDjQh8kcffWS33Xabe37BggXWokWLSq9PqTwjpfOUCRMmlPvep59+OuSxGsw+/PBDq+tyuu5gVlpimc1aWdO5zcyWbrCS0oAL/HVq3iDemwcAAGJ0yy23uFTpr7/+esi8NOoMdcopp9hxxx3nllF2BQAAAESm+fSUcvOZZ56x/Px8O/TQQ+3ZZ5+tsc/T9DSaz+/RRx91HdDV4Xz+/Pl2991328033xzxPcpiVZl5BgEAAGol6PfPf/7Tjj32WFeRUTqF3r17B1MbeGk/UbMa9dnX3aTpe7+ZTZ/l7uetWE/QDwCAJPLZZ5/ZBx98EBLw8+i566+/3g477LC4bBsAAEAiU1rON954wx5//HE37YzScc6bN89++OGHSs2N3LJlSxe4W7x4ccjzeqypYyJp166dm8vPn8pzu+22cyMDtV3Z2dll3qP0oZrmxqORfp06dYp5OwEAAGok6Lfffvu51AeqnOTm5gafP++886xBAwJOtc0f5GNePwAAksuaNWvKpJLyU0OTlgEAAMBml156qb300kvWrVs3O/300+2VV15x2afCA3GxUIBOI/U++eQTO+aYY4Ij+fQ4WmaqPffc01588UW3nOb/k+nTp7tgYKSAnyh1e12aegYAANSROf02bNjg8pB7AT+lUBg9erT98ccfLrUBalenXF/Qb8WGuG4LAAConM6dO9u3334b9fVvvvnGLQMAAIDNHn74YTv//PPd/H0XX3xxlaab8dMIvMcee8ylB/3999/twgsvtHXr1tmwYcPc60OGDHEj9Tx6fcWKFXb55Ze7YN97771nd955p9sWAACApAr6HX300cG86CtXrrT+/fu7yYrVG0qVLtSeQHGRdcraPLqPkX4AACSXk08+2TUy/fLLL2Ve+/nnn+2qq66ywYMHx2XbAAAAEtVzzz3nOk5pZJ3qSu+++66VlJRUeX1axz333GMjRoxwcytPnTrVxo8fH8zIMHfuXFu4cGFweaXl/PDDD+27776zXr162WWXXeYCgNdee221lA8AAKDW0ntOmTLF7rvvPnf/tddecxUg5Ut//fXXXeVIvZ1Q8xY9PsIK50yz7CylhlBjYJrNXUHQDwCAZKIe4x9//LFrXDrooIPcXDCBQMD1MNfzmi9Z8/oBAABgs1NOOcXdZs2aZU8//bQbYbd+/XqXbvO3336z7bffvtLrVCrPaOk8J0yYUOa5AQMG2Ndff12l7QcAAEiYkX6qRDVu3NjdVxqF4447zuUv33333V2qT9SOtMxss0DAAhsLbOtGAfcc6T0BAEguOTk59tlnn9kdd9zheo+PGzfOHnnkEVu0aJHdfvvt7jUtAwAAgLK6du1qI0eOtNmzZ9vzzz9vxx9/vJvjr2PHjm70HQAAQCqp0ki/bbfd1t566y079thjXSqDK6+80j2/ZMkSa9KkSXVvI6LIbNYqeH+nRkU2c209W7a20DZsLLH62ZWbtBoAAMRPdna2XXPNNe4GAACAyktLS7NBgwa5m+ba07Q0Tz31VLw3CwAAIPFH+imFp+aX6dKli0s5pXQG3qi/Pn36VPc2IorM3NbB+93qFwTvz2NePwAA6gyN/ouWZgoAAACb/eMf/7CVK1da8+bN7YorrrAff/wx3psEAACQ+EG/E044wU1g/P3337uRfp4DDzwwONcfajfot1Xm5kBfHkE/AACSyq+//mpjxoyxRx991DVUybJly1xj1dZbb+1SfAIAAKB8d955pxvlBwAAkKqqlN5T2rZt627z5s1zj5UrXaP+EJ+gX5vAGjNr5+4zrx8AAMnjnXfecR2qiouL3eN//etf9thjj9lJJ51kffv2tTfffNMOOeSQeG8mAABAwgsEAvHeBAAAgOQb6VdaWmq33nqrNW3a1Dp37uxuzZo1s9tuu829htqRmbt5Tr9mRZtGBUjeCkb6AQCQLG6//Xa7+OKLbfXq1TZq1CibOXOmXXbZZfb+++/b+PHjCfgBAAAAAACg5oJ+N9xwg0tBpVzpP/zwg7sphcKDDz5oN910U1VWiSpIb9jU0rKy3f2cDfnB50nvCQBA8vjjjz9c0K9Ro0Z26aWXWnp6ukuXvuuuu8Z70wAAAJLKb7/95jqmAwAApKoqBf2eeeYZe/zxx+3CCy+0Xr16udtFF13kUlE9/fTT1b+ViCgtLc0ym/3/aL/Vyyzj/79N0nsCAJA81qxZY02aNHH3MzIyrH79+m4ePwAAAESXn5/vOp8rW4KnU6dOrj61atWqMq8BAACkgirN6adJkXv27FnmeT3HhMm1KyO3tRUtnW9WXGQ9Gwfs11VpjPQDACDJfPjhhy5tuihV+ieffGK//PJLyDJHHXVUnLYOAAAg8SgD1U8//eQyJYRTveqLL75wQT9lqwIAALXjzz//tKFDh9qyZcvc9ViDxHbYYYeQZSZMmGCHHnqo9ejRI/jcpEmTXCfoTz/91K699lpbu3atG/R0+OGHu4yTyoqEGgz69e7d21WuHnjggZDn9ZxG/aH2NDtwsNn+J1hmbmtr8sLvZqtW2JqCYlu1vsiaNsiK9+YBAIAYqELsd/7554c8VkW3pKSklrcKAAAgcb3++ut27733Rn1d9amrrrqKoB8AALVI19/zzjvPzjzzTHvttdfc/999912Z5RTwmzp1apnnc3Nz7eWXX3YZkAoKCmzgwIH27LPPuvUgNlUKj/7rX/+yJ5980rbffns7++yz3U33FbW95557qrJKVFG9DttYvU7dLaNRM+vUokHweUb7AQCQHDSyr6IbAT8AAIBQf/31l3Xr1i3q63pNyyC5Rofsscce1r17dze/9a+//lpmGY0O0UiQnXfeOXjbsGHTNDezZ8+2/fbbz40s0fMAgNq1ZMkS+/777+300093j48//njLy8uzGTNmxLyOPn36BKc8ycnJcedznd9Rw0G/fffd16ZPn27HHnusrVy50t2OO+44dzF+7rnnqrJKVINOub6g3wqCfgAAAAAAoG7S3H0LFiyI+rpeIxVYco4OUZvjNddcE3VUhzc6xLspCCiaJ/v222+3F198sZa3HAAgCvC1a9fOMjMzg1mLttpqK5s7d26ZZdUxZ5dddnGdPB566KGI61u0aJEbLXjEEUfU+LbXJVWu/bRv397uuOMOl05BN11UNYnyE088Ub1biJh1as5IPwAAsMnYsWOtS5curmdc//797dtvv426rHpEqzIeflPufAAAgESkkQBvvfVW1NfffPNNtwxSZ3RI8+bNba+99rKGDRvW4JYCALaUgn3z5s2zKVOmuOv1uHHj7NVXXw1ZRvPyHnnkkXb11Vdbv3794ratyYguT0kuUFpq66d9b6snvW/dFm1uzMtbsSm1AQAASD2vvPKKDR8+3G6++WZXidZ8zIMGDXKNKZG88cYbtnDhwuDtl19+cb3nTzzxxFrfdgAAgFhccsklbk6/MWPGhKRC1/0HH3zQ7rvvPrv44ovjuo2I3+gQAEDt69Spk2tTKC4udo8DgYA7j+t87qeR2UrFLB07drRTTjnFvvjii+Dra9assUMOOcSOPvpo17aByiHol+zS0mzZvx+w/Peessa/fhJ8mpF+AACkrlGjRtm5555rw4YNc/Muq9dcgwYN3JzM0XpFt23bNnj76KOP3PIE/QAAQKLSSDD1/r/ssstcXUaj+nTT/SuuuMI1Ep5wwgnx3sw6PYeeKOOX5k/cZpttXP2zqKgo7qNDAADx0bp1a3eefv75591jZYhUUG/bbbcNWU6BwdLS0mCA79133w2Ozl+7dq0L+Ol24403puS1bktt6j6DpKWeT5nNWlnR4rkWWLPM6meabShmTj8AAFLVxo0bbfLkyXbdddcFn9N8NgMHDrRJkybFtA5VaE8++eRyUyMVFha6mz/1hqji7lXe6xKVSb0U62LZYpHK5U/lsgvlp/ypWv5ULnttlL+61qtpZzQK4IUXXnBpILXN++67r5166qm22267VctnpMIcepo7T3Mm6f/vvvsu6hx64WbNmmU33XSTC8C1adPGfRePPvpolUZY+keHaLRfeaNDPP7RISeddFKlPxMAUP0eeeQRdz2588473Tn7qaeecs+fc845dtRRR7mbgoEPP/ywO9/rvK8Ox+q0LPfff7+bnmTdunUuK5Ho9RtuuCHpr3UJGfQ77rjjyn195cqVW7o9qILM3NYu6GclJbZD04B9vzzN5uVvcBUkBQUBAEDyUMDu999/d/c1Sk+95Cpj2bJlLq2VKqN+ejxt2rQK36/KtdJ7VjRP81133WUjR44s8/zSpUutoKDA6ho1Tq5atcrVrxRETTWpXP5ULrtQfsqfquVP5bLXRvnVq7+6KLhHgK/qc+j997//DY6cVMpUBU/DR2REo8ZTNd4qU4RccMEFrpG3Kg2h/tEhapAtb3SI6rU6Lr3RIWeffXalPw8AUDMUPIvU4fjxxx8P3tf1RrdIFNyraoAv0a91CRn08/Kslvf6kCFDtnSbUEmZua2C97dvuNG+X17PCotLbemaQmvdJCeu2wYAAGKvjGp0ndJKNGvWLNihav/997eXX37ZWrXafL2vSQr27bTTThU2nmkkoT+3vkb6qYe2ttPfA7suNX6qM5XKl6qNv6la/lQuu1B+yp+q5U/lstdG+XNyqq+tQr31X3rpJZs+fXqwsVGjv/r161dtn5Fqc+iFN4R6c+hpzmeNxLjooovc81q2c+fOweW6dOkScQ6+2hodsn79epe+TdkoFLRW0PCMM85wndUAAKknLwGvdQkX9PMutkgsmbmbe/JvU0+5ZusF5/Uj6AcAQHK49NJLXW9l5Zffbrvt3HO//fabDR061M1Vo8asWLRs2dJVUhcvXhzyvB57PdOiUfoMBRhvvfXWCj+nXr167hZODYN1tXFUfyDU5fJVJJXLn8plF8pP+VO1/Klc9pouf3WtU3P63XPPPdaoUSPbeuut3XP/+9//bPTo0XbVVVfZP//5z2r5nFTmzaGnjv76/7DDDnP1zZpIp7mlo0M0J7W2EQCARL3W1YbUrLnWMZrTz9MxfW3wft6KzZNNAgCAxDZ+/Hh76KGHggE/L73n2LFj7YMPPoh5PdnZ2da3b1/75JNPQnrr6/GAAQPKfe+///1v1zP69NNPr2IpAAAAasczzzxjDz74oD3wwAO2fPlyNw+PbitWrLD77rvPPf/ss8/GezMTln8OPSlvDj0v85d/Dj3RsnPmzAkuO3v27DLvBwAgXjql6LWOoF8dmdPP06J0c178vBXr47RFAACgshSYy8rKKvO8ntNrlaG0m4899phrDNP8gBdeeKEbxeelPlI6dqXnjJTa85hjjrEWLVpsQUkAAABqnjpGKQ2kRn3561C6rywJd9xxh40ZMyau25jI/HPoSXlz6Hl1UW8OvT59+gTnRnrnnXds0aJFriF13LhxLl09AACJoHWKXusI+tWxOf0aF64M3ld6TwAAkBwOOOAAu/zyy23BggXB5+bPn29XXnmlHXjggZVa1+DBg12qqxEjRtjOO+/ser1rJGGbNptSgqtnmyq1fn/88YdNnDjRzj777GoqEQAAQM1RSvSjjz466uvqyKRlUP4cerppHrx//OMfIXPoqYHTayDVfM+9e/e23Xff3Q466KBgRzKlVB05cqTtueeergFVc0Cef/75cS0TAKDmlZQGLFm255EUvNalBRSeRIjVq1e74Zya9FdDO6ubosZLlixxkebqymOfd8eZVrphnaU1bWn7LD/CPTdg6xb20nm7WyKpibInC8pO2VOp7KlabqHsqVf26qo3aILpo446yjVOKQWF99yOO+7oKqLqjZbK9ad4S9Xj25PK5U/lsgvlp/ypWv5ULnttlL866g1637fffms9e/aM+Lo6NO26667usxJVXa8/AQDqrstf/sFmLNk81Vi8bNu6kd1/8qZReXXd6hjrDZm1ulWoMVltu1igYL1ltmhrjddm2JrCEkb6AQCQRBTomzJlin388cc2bdo095zm9xs4cGC8Nw0AACDhKF3XCy+8YLfddlvE15977jm3TDJYurrACiw7+LheZoY1bZBlxSWltmLdxjLLt26S4/7Xa1rGr0n9LMvJyrD1G4ttbcGmOYw8WRnpltsw20pLA7ZsbWGZ9bZoVM8y0tNs5fqNtrE4dL0N62W6W0FRia3eUBTymt6j98qS1QVl1qvP1Gev2lBkhUUlIa/Vz86wxjlZVlhcYqvWh643LS3NWjXetN6lawpdWjU/7SPtqzUFRbZhY+h662VlWNP6WVZUUmr55ezD5WsLy4wQ8fbhusJid/PLzky3Zg2y3Xv03nAtG9Wz9PQ095n6bL9GOZnWIDvyPszMSLfmDbOj7kO9pmW0j7Sv/BrUy7RG9TIj7kNti7Yp2j5UWVSmSPswJzvDmuRE2YdpZq0bV20fesd3tH2o71zffaR9qGNFx4y2Vdsc6fhWGVXWaMd3pH0Y8/G9psAsEPn4Xl1QZAUbIx/f+j3pdxXt+NbvUb/LSMf32sJiWx9lH3KO4BwRz3PEH4vW2LRFm6caixftR2+f1PVzxJoI330kBP3qiLZn3xK83+n+L+y3hatt4aoCd2LXDx4AACSuoqIiq1+/vkvDqTQSugEAACC6q666yqXwLCwstL/97W/BNOaac+fee++10aNH25tvvmnJ4O2vfrP6DRoFH2/TPtcO3mUbW7Oh0F7/vGyK0guP6Of+/3TKDFu6KrTD9369u9h2nVra9HnLbdJveSGvtW/R2I4e0MM2Fhfb65//Uma9Qwb2soY52Tbxl9mWtyR0hORuPTtY323b2dwlK+2TH2aFvNa8SX0bvM8O7v6bE38tE7w4Ye/trFXThvb9H/Nset5yFzDy9OraxvbcoZMtXrHW3vv2z5D3NczJsiEDe7v7H3wzzdaFNeAevls326p1U/vpr0X206zFIa9179jCDty5q61cu8Fe/+L3Mo3c5x/W1wKlpfbxlBm2YvWGkNcP7NPVundoYdPyltq30+aHvNapdRM7YrfuVrCxKOI+HHZwb8vJzrLPf5plC5aHNoYP2L6T7bx1G5u1KN8m/Dg75LVWTRvYCXtv7+5HWu/J++1guY3q2zfT5tpfC/JDXuuzbTvbvWcHW7hsjX3w/YyQ1xo3qGenH7CTu/+fSb9b4cbQAMVRA3pYhxaN7YcZC+3X2UtCXttuq5a2X68utmL1envjy02dEj1ZmRl2ziGbRtb89/s/beXa0Ibog/tuY9u0y7Xf5iyx76dvnr5AOrdtZof129bWFWyMWFatV+uf8ONMW7QidBTR3jtuZTt2aW1/LVhuX/wyN+S1ts0b2bF79HRtoZHWe9oBO1mTBvXsy9/m2JxFm6dHkn7d29uu3dvb/GWr7b+T/wp5rVmjHDtlvx3d/Xe+/N2KwoIBx+3Z09rkNrIp0+fb73OXhby2Q5fWts+OW9nSVevsnUl/hLxWLzvTzjp4Z3d//LfTbc360CDEof22tS5tm9kvsxa778evTp8j5i0PeS2e5wjhHBH9HBEoXOf+z7BSa2plg1ErrIH7X69pGb+1lm0bLdPqW5G7+W20DFtr9SzdSq1ZxPXWdz0PmliBZVqpBdZuPl7r+jliw/rYRlYS9KuDOjWv74J+6lGgwF+n5pt+YAAAIDFlZWXZVlttZSUloZVDAAAARHbEEUfYfffd54J/CvIp3ZUo5VVmZqab31jLJIPD0mdY4/TNbTfZ1lnN+tYwUGRHpU+P8I5NDfp7pedZSXpoA3mTtOYaS2Jd0/KtVdh7M9MUGO1hWRaIuN5s29Qov1vaAuuTHhqoaZim7Wtn7W1NmfdmpDVT06W7f0S6GuXDRmfZNlqD9U5bbD0zZtqG6VOs9P8bLjOm1bOFE+pZoKjYDlwflrEqPd0W/rEpGLr7mrXKOxvycmBGA1uYlWltNxRaq42hAZP037Nt4Zc5VlRcageuC20kDaSZLVs30VqeeLntmzbHStJDG3ebWkuN+bBt0vKtbVhZs9LaK1xg2VYScR9mWa9N25s2z4rTQ4MMjdJUljbWMW112X2Y3sLMNjXoR1pvw0B3jQmxPrbIdkifE/JagzSN/ulgrdLWlXlvero+c1OD/iHpf1kgPXQ/Nbet3De0Q9oS2ybsvTlp2t9drGlaYdltSleT8qag335ps600PTQA1NR0rOVat7QV1j7svdmmqQy2tfpWHLGsGbapkXuPtDwrTl8a8lpjd6y1tq0i7MPMtFZm1tMyohzf9W07NaPbrrbQeqeHBrsapmlUV3trY2vL7sM0pdDb1KB/qI7v9NCgSNO0rvp2bae0JdYtPTSgkuMC3FtZc9tQZr1p6RrBs6msB6bPstL00OO0WVo7/Ws90pZbpzL7sA6fI9JnhrxWP02DWTpZi7T1ZfdhmoI/m4J+A9NmWiA9NDjXLK2DOxq3S1tqXcLeWy9tazPrao1tY4TjW5+5KejHOSL6OeKvtCL7w1q6oN5R6aEBq6JAhr0Q2FTW/dNmWbO00ODdJ6VbW541tW62wnYJO5bmBJrZZ4GuluPOEaHrledKe1uJpblzRNu0tdYiPduOSl+XEueINenr7W9WMeb0qyNz+vnd/u5v9vjETT0qXjynv+2xrU5EiSGV50Wg7JQ9lcqequUWyp56Za+uesMTTzxhb7zxhktF1by5/hBLLnV9TppUPb49qVz+VC67UH7Kn6rlT+WyJ8ucfh7Ngfzaa6/Zn39uGgHSvXt3O/74413q9A0bNrhsConK2w/L580O2Q9pmVmWUb+RBUpKrGR92TkJMxvnuv9L1q22QGlop7H0nAaWnlXPSjcWWGlhaAN4WkamZTRo7Ea4laxbVWa9GQ2bWFp6hpWsX2OBktBGy/TsHEuvV99KiwqttCA0OJeWnm4ZDTcFXYvX5Jddb4PG7rNLN6yz0uKNtuSp26xoSWiDam3LbtfV2l38L7cftD8i7sPCDW4/Rt6HJW7/h9N+0P6IuA/r1Xf7MfI+zHD7P/o+bGJpGRlWsmGtBYqLIn43el6vh6w3Ld0yGm36bkrWriyTuk/HmY43bY+2K2S9WdmWntPQlUPlCVmv3hs8Dsvuw4ychpaWlR15H3rHd7R92KiZS2sXeR82sPRsHd+FVlq4PvJ3Ewi4skY9vsvbh0UbraRgXdTju2RNfnjmvs3Hd8E6Ky0KTc+n40jHU+TvJs2V1a137SoLBEojfzfl7cM6eo6o2j6s5PGdmW3p9SMf36H7kHNEtH04+InJNnlRYdxH+vVo09ieO6d/SpwjVq9ebS06dkmOOf3Gjh1rd999t0vB0Lt3b3vwwQdtt912q/B9L7/8sp1yyil29NFH21tvvRV8Xl/czTffbI899pitXLnS9txzT3v44YetW7dulgr8I/uY1w8AgOQwZswYmzFjhrVv3946d+5sDRs2DHld8/0BAAAglIJ7V155ZchzSvk5atQo+9e//uXamhKdGpczG5dtvFMDrtfwHInXAByJa6DM3jQnVZn1pqeXv94GjaOvVw2UWZvmGIqkvPWqgT3dGrrGz0ThNdRG4hrg60UOGqthOB77UA3w0ahhvtz3/n/jccRtUhAjJ3KmMH1f5R+HcdiH2fXcLeJ609Kqvg+zsi0zKzv6e8s7vnMaulvVvpsq7sM6eo6wVD++k+QcUeBGohVaiaUHA3yRrLLIx5lssCx3i6S0gvWu/v/11mvaPBhMTYRzRKC0NGRbqvMckRnIsFjE/Sr7yiuv2PDhw23cuHHWv39/l3N90KBB9scff7geZdHMnj3bpXDYe++9y7ymSt0DDzxgzzzzjHXt2tVuuukmt87ffvvNcnKiH2TJTFHkZW88ZMX5S6xvroaMbgpw/jJ/tQ3eNd5bBwAAKqI5aQAAABAbBfZuueUW++ijjyw7O9uuvvpqV5966qmn7IYbbrCMjIwywcBUpKlfMtJ9k+gBAFCHNKmf6YJsy/59vxUtCZ1jsbZlte7gUkfHW9yDfup5de6559qwYcPcYwX/3nvvPXvyySft2muvjfgezXdz2mmn2ciRI+2LL75wo/n8o/wUOLzxxhvdCEB59tln3YTOGg148sknW12UVq++Ffw51d3Prd/YMtO7W3FpwCbOCJ0cEgAAJCZlKQAAAEBsRowYYY888ogNHDjQvvrqKzvxxBNd29LXX3/t2pr0WIG/VKeA3+Uv/2AzloSmDYuH/Xq0sr8P6hnvzQAA1EEK+G1cuGnKs1QX16Dfxo0bbfLkyXbdddcFn1OueFXYJk2aFPV9t956qxsFePbZZ7ugn9+sWbNc6gatw6P86BpFqHVGCvqpd5huHuVG9XLY61bdtE4FJ6t13cpD3LCJlSpX86pl1merZvbd7HybtWyd5S1fZx1yEyOHfY2UPUlQdsqeSlK13ELZU6/s1VXe7777zq1LdRa/b775xjVY9eu3aTJ2AAAAmP373/92nbyPOuoo++WXX6xXr15WXFxsP/74o0vdhc0U8Pt1Qdm5pWrbNq0ipzUDAAB1JOi3bNkyN2pPo/D89HjatGkR3zNx4kR74oknbOrUTaPawnm52iOtM1oe97vuusuNGgy3dOlSKygoO1nkllKDniZbVMNodU6IHWiUa7ZutZWsXmF9u2XZd7M3Pf/+D7Ps6B1bWiKoqbInA8pO2VOp7KlabqHsqVf2NWvKTvpdFRdffLFLSxUe9Js/f77985//dME/AAAAbDJv3jzr27evu7/jjjtavXr1XDpPAn4AACCVxT295/+1dydwTtTn48efJJts9t5lT1juSxQRBARR1HqBR1XUVjxB2tLWoz+tf+8qnq1Vq6W1Hq0V76tWa221WIvFiuKFIoiA3PfCLux9JZvk/3q+2WST3SwsuLvZJJ/3iyEzk5lkvjs5JvPM83z396TaJZdcIo8//rjk5XVeEEszDbVfwdBMP+0IOj8/XzIz2+/w9NucFNWDUH38zjwpWpbfR+p3btLwn0wdnCaPNZ8bXLazUWaf0H7/iN2pq9oeC2g7bU+ktidquxVtT7y2d1Z/wdr38NixY9vMP/zww819AAAAaKEXkWtffgFJSUmSnp4e1W0CAABI6KCfBu60XNXOnTvD5ut0UVFRm+XXrVsnGzdulDPOOKNNSS09uFu9enVwPX2M3r17hz3mmDFjIm6HXg2mQ2t6wrKrTlrqSdHOfnx7ToHUN48PS3FJhjNJqhua5MN1u/UZxdpDOm7uirbHCtpO2xNJorZb0fbEantntVWPRfR4ZfDgwWHzd+zYYY5zAAAA0EKrS1x66aXB8zlaqemnP/2ppKWFl5B87bXXorSFAAAA3S+qZ+T0iiwtxbBgwYKwIJ5OT5o0qc3yI0aMkOXLl5vSnoFBa7cff/zxZlyz8wYNGmQCf6GPqZl7WhIr0mPGk6Sclmw+X2WpHDUk14yX17l7RO12AADQvilTppjqA1oiNaCiokJuvvlmOfnkk6O6bQAAAD3NzJkzpaCgQLKyssxw8cUXS58+fYLTgQEAACCRRP2ycS2rqQdq48ePlwkTJsjcuXOltrZWZs2aZe6fMWOGFBcXm373tHyW1mkPlZ2dbW5D51999dVy9913y7Bhw0wQ8NZbbzUHftOmTZNECfo1lZfK5GHD5e0V/izK99eWyqi+HOwCANBT/eY3v5Fjjz1WBgwYYEp6Kr2oSfslfvbZZ6O9eQAAAD3Kk08+Ge1NAAAA6HGiHvSbPn26lJaWypw5c6SkpMSU4Jw/f745waU2b96832Wzrr/+ehM4/PGPf2yukJ88ebJ5zM7qc6enSsrOD443le+SY8a29Hu4aE2ZXP6doVHaMgAAsC96kdOyZcvk+eefly+//FJSUlLMRVAXXHCB2O32aG8eAAAAAAAAerioB/3UlVdeaYZIFi5cuNd1n3rqqYj9Cd15551mSCRhQb+KXTIgN1X65qTI1vJ6+WxjudS7PJLisEV1GwEAQPu0Dxq9aAkAAAAAAACIyaAfOofF7pDsk84Xa1qW2POLTfDzmGF58uInW8Tl8conG/fIccNbAoMAAKDn+frrr02lA5fLFTZf+zEGAAAAAAAA2kPQL85kfefcsOnJQ/NN0E8tWlNK0A8AgB5q/fr1cvbZZ8vy5cvNhTs+n8/M13Hl8XiivIUAAAAAAADoyfavszzEnKOG5ErzuUJ5f01ZtDcHAAC046qrrpJBgwbJrl27JDU1VVasWCH/+9//ZPz48fssdw4AAAAAAAAQ9ItzOWkOGVWcZcZXlVRLaXVjtDcJAABEsHjxYtMfcV5enlitVjNMnjxZ7rnnHvm///u/aG8eAAAAAAAAejiCfnHG5/GIe89OqV+3XNy7tpp5k4fmBe//YC3ZfgAA9ERavjMjI8OMa+Bv+/btZnzAgAGyevXqKG8dAAAAAAAAejqCfnGmYePXsv3BK2XXk3dKzef/NfMmD2sJ+lHiEwCAnunQQw+VL7/80oxPnDhR7rvvPvnggw9M9t/gwYOjvXkAAAAAAADo4ZKivQHoXEk5BcHxpvJd5nbcgBxJsduk3u2RRWtLxefziSXQ0R8AAOgRbrnlFqmtrTXjGuj77ne/K8ccc4zk5ubKyy+/HO3NAwAAAAAAQA9H0C/OJGXlimhAz+eTpopSMy85ySYTBvWS974plZ1VjbJ2V40MK/SXDwMAAD3D1KlTg+NDhw6VVatWyZ49eyQnJ4eLdQAAAAAAALBPlPeMMxZbktgyc8My/dQxlPgEACDm9OrVi4AfAAAAAAAAOoRMvziUlJMvnsoy8dZVi7exXqzJKWH9+i1aWyY/mDwoqtsIAAD8fvCDH3RouXnz5nX5tgAAAAAAACB2EfSL0379GjeuDGb7OYoGyEGFGZKfkSyl1Y3y0frd4mryiiOJRE8AAKLtqaeekgEDBsjhhx9u+t0FAAAAAAAADgRBvziUlF0QHA8E/bQ02OShefK3L7ZJncsjX2wul4mD/WVAAQBA9Fx22WXy4osvyoYNG2TWrFly8cUXm7KeAAAAAAAAwP4g1StOM/0CmvaUBMc16Bda4hMAAETfww8/LDt27JDrr79e/vGPf0i/fv3kvPPOk7fffpvMPwAAAAAAAHQYQb845Og9IDhe/80XwfHQfv3eX0PQDwCAniI5OVkuuOACeeedd+Trr7+WkSNHyuWXXy4DBw6UmpqaaG8eAAAAAAAAYgBBvzhkLxootux8sTiSxZqWJT6v18wvzHTK8MJ0M75sa4VU1rmjvKUAAKA1q9VqynJrlp/H44n25gAAAAAAACBGEPSLQ3qisOCSm6TvTU9I/nlXicXaspsnD803t16fyOL1ZPsBANATNDY2mn79Tj75ZBk+fLgsX75c/vCHP8jmzZslPd1/wQ4AAAAAAACwNwT94pSjsJ9Y7clt5h9DiU8AAHoULePZu3dv+fWvfy3f/e53ZcuWLfLKK6/IaaedZrL+AAAA0H19LWt5dafTKRMnTpRPPvmkQ+u99NJL5gLsadOmdfk2AgAA7E3SXu9F3Jk4uJfYbRZxe3yyaC1BPwAAou2xxx6T/v37y+DBg+W9994zQySvvfZat28bAABAonj55ZflmmuuMcdmGvCbO3euTJ06VVavXi0FBQXtrrdx40a59tpr5ZhjjunW7QUAAIiEy8cTgNfdKE1Vu814qiNJxvbPMeObdtfJlj11Ud46AAAS24wZM+T444+X7OxsycrKancAAABA13nwwQdl9uzZMmvWLDnkkENM8C81NVXmzZvX7jra//JFF10kd9xxh7mACwAAINrI9Itjntoq2fPG41L/zReSMmyM5F94bbDE58cb9gRLfF44sX+UtxQAgMT11FNPRXsTAAAAEprL5ZIlS5bITTfdFJynZdZPOukkWbx4cbvr3XnnnSYL8Ic//KG8//773bS1AAAA7SPTL45ZU9KkYePX4nM3Sv2aL8TrajDzJw/LDy6zaG1pFLcQAAAAAAAgusrKykzWXmFhYdh8nS4pKYm4zqJFi+SJJ56Qxx9/vMPP09jYKFVVVWEDAABAZyLoF8csVpukHnyEGfe5XVK/ZqkZH1WcJVkpdjP+wdrd4vH6orqdAAAAAAAAsaK6ulouueQSE/DLy8vr8Hr33HNPWPn2fv36del2AgCAxEPQL86ljjwyOF634iNza7Na5KghuWa8st4tX22rjNr2AQAAAAAARJMG7mw2m+zcuTNsvk4XFRW1WX7dunWyceNGOeOMMyQpKckMzzzzjLzxxhtmXO+PRMuHVlZWBoctW7Z0WZsAAEBiIugX55yDRorVmWbG61ctMRl/avKwlivRFq0ti9r2AQAAAAAARJPD4ZBx48bJggULgvO8Xq+ZnjRpUpvlR4wYIcuXL5elS5cGhzPPPFOOP/54M95eBl9ycrJkZmaGDQAAAJ0pqVMfDT2OJckuKSPGS+3S98TnapD6dcskdcR4OWZoS79+768plSuOHxrV7QQAAAAAAIiWa665RmbOnCnjx4+XCRMmyNy5c6W2tlZmzZpl7p8xY4YUFxebEp1Op1MOPfTQsPWzs7PNbev5AAAA3YmgXwJIHTnRBP0CJT416Nc/N1X690qVzXvqZMmmcqlzNUmqg5cDAAAAAABIPNOnT5fS0lKZM2eOlJSUyJgxY2T+/PlSWFho7t+8ebNYrRTMAgAAPRtRngSQMnS0WBxOf6bfqs/E52kSiy3JlPh84ePN4vb45OMNe+T4gwqivakAAAAAAABRceWVV5ohkoULF+513aeeeqqLtgoAAKDjuEQpAVjsDkk5aJwZ99bXSsP6FWb8mKEh/fqtoV8/AAAAAAAAAACAWEXQL4FKfKqkvD7ia3KZ8aOG5InV4r+foB8AAAAAAAAAAEDsorxngkgZPlZ6/+xBsRf0FYvFH+nLSrXLqL7Z8uWWClm9s1p2VTVIQaYz2psKAAAAAAAAAACA/USmX4KwOpLFUdgvGPALCCvxuZZsPwAAAAAAAAAAgFjUI4J+Dz/8sAwcOFCcTqdMnDhRPvnkk3aXfe2112T8+PGSnZ0taWlpMmbMGHn22WfDlrn00ktNcCt0OOWUU7qhJbFn8jD69QMAIB7tz/GVqqiokCuuuEJ69+4tycnJMnz4cHnrrbe6bXsBAAAAAAAQ4+U9X375ZbnmmmvkscceMyek5s6dK1OnTpXVq1dLQUFBm+V79eolv/jFL2TEiBHicDjkn//8p8yaNcssq+sFaJDvySefDE7rySu0cO/ZKUnZ+TK2f46kOmxS5/KYTD+fz9cmGxAAAMSW/T2+crlccvLJJ5v7/vrXv0pxcbFs2rTJXGQFAAAAAACA2BD1TL8HH3xQZs+ebQJ3hxxyiDk5lZqaKvPmzYu4/He+8x05++yz5eCDD5YhQ4bIVVddJYcddpgsWrQobDkN8hUVFQWHnJycbmpRz1a7/APZ/odrZfuDV4pr21pxJFll4qBe5r5d1Y3yzc6aaG8iAADo5uMrnb9nzx55/fXX5eijjzYZgscdd5yMHj2627cdAAAAAAAAMZjpp1eVL1myRG666abgPKvVKieddJIsXrx4n+trVtq7775rrlq/9957w+5buHChuVpdg30nnHCC3H333ZKbmyuJzudqFHfJJjNet+IjSe43XCYPy5f/ri41895fUyoHFWVEeSsBAEB3Hl+98cYbMmnSJFPe8+9//7vk5+fLhRdeKDfccIPYbLaI6zQ2NpohoKqqytx6vV4zxBttkx57xmPbOiKR25/IbVe0n/YnavsTue3d0f5E/bsCAADEddCvrKxMPB6PFBYWhs3X6VWrVrW7XmVlpSk7pSea9ETUI488YkpShZb2POecc2TQoEGybt06ufnmm+XUU081J7oinbjq7pNW0fzxkHzQOD3zpxshtSs+lsyTL5Kjh/gz/dT7a8rkB0cP7LLnT+QfTrSdtieSRG23ou2J1/ae1t4DOb5av369uZDqoosuMv34rV27Vi6//HJxu91y2223RVznnnvukTvuuKPN/NLSUmloaJB43M96DKqvcQ2iJppEbn8it13RftqfqO1P5LZ3R/urq6s7/TEBAADQA/r0OxAZGRmydOlSqampkQULFpg+awYPHmxKf6rzzz8/uOyoUaNM+U8tBarZfyeeeGLUT1pF+8eDpc9Q8W39Rjzlu2Tn159LVl5fyU+zS2mtWz5ev1u2bi8xZT+7QrTbHk20nbYnUtsTtd2Ktide2+PhpJXuO62Q8Kc//clcIDVu3DjZtm2b3H///e0G/TSTUI/BQi+a6tevn8kSzMzMlHijfyPt91jbl0iv74BEbn8it13RftqfqO1P5LZ3R/udTmenPyYAAACiHPTLy8szJ5Z27twZNl+ntR++9ugB59ChQ834mDFjZOXKlSZwFwj6taYBQX0uvWo9UtCvu09aRfvHQ82YY6R86zdmPGXHGskaOU6OGb5TXvtimzQ0eWVrg12OHNw1pVCj3fZoou20PZHanqjtVrQ98dre005aHcjxVe/evcVut4dVRND+k0tKSky5UIfD0WYd7T9Zh9Z038fr/tfXdzy3b18Suf2J3HZF+2l/orY/kdve1e1P1L8pAABAXAf99ASSXkmu2XrTpk0LnjDU6SuvvLLDj6PrhJbnbG3r1q2ye/duc0IrkmictIrmj4e0kROl/M152imi1K38RHKmXCjHDM8zQT/1wbrdctTQ/C57/kT+4UTbaXsiSdR2K9qeWG3vaW09kOOro48+Wl544QWzXKA933zzjTl2ihTwAwAAAAAAQM8T9bNUmmH3+OOPy9NPP20y9i677DKpra2VWbNmmftnzJhhMvECNKPvnXfeMX3P6PIPPPCAPPvss3LxxReb+7Xk53XXXScfffSRbNy40ZzgOuuss0xm4NSpU6PWzp7ElpEjyf0PMuNNpdvEtWuLHD00L3j/ojVlUdw6AADQ3cdXev+ePXvkqquuMsG+N998U371q1/JFVdcEcVWAAAAAAAAIKb69Js+fbrpO2/OnDmmhJSW65w/f74UFhaa+zdv3hx2Bb2esLr88stN9l5KSoqMGDFCnnvuOfM4SstSLVu2zJzkqqiokD59+siUKVPkrrvuipjNl6hSRx4pjZtWmfG6FR9LwfHfkxFFGbKqpFqWbauUijqXZKdyZT8AALFof4+vtKz522+/LT//+c9NX8jFxcUmAHjDDTdEsRUAAAAAAACIqaCf0lJT7ZWbWrhwYdj03XffbYb2aCBQT1ph71IPmSDlbz1lxutWfCTZx39PJg/NM0E/n0/kw3W75bRRkcuhAgCAnm9/jq/UpEmTTKUEAAAAAAAAxKaol/dEdCRl54ujeIiILUmSsvLE53bJ5GEtJT7fp8QnAAAAAAAAAABAzOgRmX6IjrxzrxRbZi+xOlPN9MRBueKwWcXl8cqitaXR3jwAAAAAAAAAAAB0EJl+Ccxe0DcY8FMpDpuMG5BjxrfsqZdNu2ujuHUAAAAAAAAAAADoKIJ+CEOJTwAAAAAAAAAAgNhD0A+Gr8ktTRVlckxI0G8RQT8AAAAAAAAAAICYQJ9+Cc7rbpQ9f/+T1K9aIvbC/jLyh3dIdqpdKurc8sG6MmnyeCXJRmwYAAAAAAAAAACgJyOak+Cs9mRp3LZOvA210rh5lUhthRw9xJ/tV93QJMu2VUZ7EwEAAAAAAAAAALAPBP0gqYdM9I/4fFK38tOwfv0o8QkAAAAAAAAAANDzEfSDpI08Mjhet+IjmTyUoB8AAAAAAAAAAEAsIegHsfceKEk5BWa8YcMK6eP0yMDcVDP9+eZyqWlsivIWAgAAAAAAAAAAYG8I+kEsFoukjmwu8en1Sv3Kz4IlPpu8Pvl4/e7obiAAAAAAAAAAAAD2iqAfjNTQEp9fa4nP/OD0+5T4BAAAAAAAAAAA6NEI+sFwFA8VW2YvM16/dpkc2TdFrBb/fYvWEvQDAAAAAAAAAADoyQj6wbBYrZJ6SHOJT0+T2Dctk9H9ss3k2l01sqOyProbCAAAAAAAAAAAgHYR9ENQoF8/W1ae+DweOWaov18/tYgSnwAAAAAAAAAAAD0WQT8EJQ8YIUWX/VqKr31E0sd+RyYPa+nXjxKfAAAAAAAAAAAAPRdBPwRZrDZJLh4iFou/M7/D+2dLmsNmxj9YWyZery/KWwgAAAAAAAAAAIBICPqhXXabVY4cnGvGy2pcsqqkOtqbBAAAAAAAAAAAgAgI+qFdTVW75ZjB2cHpRWtLo7o9AAAAAAAAAAAAiIygH9qo/+YL2fHHm2XbfT+VY5JLgvPfX0O/fgAAAAAAAAAAAD0RQT+04fN6xLVljRnP2rpMijKdZvyTDXukwe2J8tYBAAAAAAAAAACgNYJ+aCNlyGFicfgDffWrPpVjh+aY8cYmryzZVB7lrQMAAAAAAAAAAEBrBP3QhsXukJSDxplxb32tTM2qCN5HiU8AAAAAAAAAAICeh6AfIkodOTE4PqJ6VXB80drSKG0RAAAAAAAAAAAA2kPQDxGlDD/cZPwp75rP5ZCidDO+YnuV7Kl1RXnrAAAAAAAAAAAAEIqgHyKyOpySMuxwM+6trZRzCmvNuM8n8sFaSnwCAAAAAAAAAAD0JAT90KESnxM9G4Lji+jXDwAAAAAAAAAAoEch6Id2pRw0TsSWZMazty2T5CSLGV+0tkx8mvIHAAAAAAAAAACAHoGgH9pldaZKytDDRKxWceQXy7H9nGb+top62VDmL/cJAADQ1Txenyxet1v+vnSbudVpAAAAAAAAhPOncQHtyDn1Usk9J01saZkyduE6eWfDqmC23+D89GhvHgAAiHPzv9ohd/zja9lR2RCc1zvLKbedcYiccmjvqG4bAAAAAABAT0KmH/bKntfbBPzUMcPygvPfp18/AADQDQG/y577PCzgp0oqG8x8vR8AAHQuzaj/aP1u+feqPeaWDHsAAIDY0SOCfg8//LAMHDhQnE6nTJw4UT755JN2l33ttddk/Pjxkp2dLWlpaTJmzBh59tlnw5bR/ubmzJkjvXv3lpSUFDnppJNkzZo13dCS+HZI70zpleYw4x+t2y1NHm+0NwkAAMQpPcGoGX6RTjMG5un9nIgEEK8obYxo0AtqJt/7rlz4509kzvwN5lanudAGAAAgNkQ96Pfyyy/LNddcI7fddpt8/vnnMnr0aJk6dars2rUr4vK9evWSX/ziF7J48WJZtmyZzJo1ywxvv/12cJn77rtPfv/738tjjz0mH3/8sQkO6mM2NIRfJY79YxGvTO3vrwhb3dgkX26tiPYmAQCAOPXJhj1tMvxC6alvvf/VJVulztXUrdsGAN0VeLng8Y/kqpeWmlsCL+hqZNgDAADEvqj36ffggw/K7NmzTeBOaaDuzTfflHnz5smNN97YZvnvfOc7YdNXXXWVPP3007Jo0SIT2NMsv7lz58ott9wiZ511llnmmWeekcLCQnn99dfl/PPP76aWxQ+f1yt7/vmE1K34WGZakuVFOS1Y4nPcgF7R3jwAABCHdlV37GKt619dZoa89GTp3ytF+vdKNUO/5tv+ualSmOEUq9XS5dsMAJ0ZeGmd1xcIvDx68Vj6NI0heo7C5/NfrGLGza1O++dLq+nWy+mITmmiZ+v1m/9FXn8vj+1PGg2dJ9Lk9cotr3/Vboa9pTnD/uRDisTGdyoAAECPFdWgn8vlkiVLlshNN90UnGe1Wk05Ts3k2xc9WH333Xdl9erVcu+995p5GzZskJKSEvMYAVlZWaZsqD4mQb/9Z7Faxb1zi3hrKyVFRAZIhWySbFm0pkyuPml4tDcPAADEoYIM534tX1bTaIbPN7etROCwWaVvSEAwNCiot+nJUb8ODgCMynr3XgMv6v/95UtZvH63WEwYJnIgKSyo0ybo0zpgFLp+y7T+5/X5TMUcu2NrcBv8waT2Aln+af92hTxve+MR1teRNoGsvTy2N2R72wustQTAItwX0qbWgTWv1ytisez9sYPPHSmwFj8CGfaaiT9pSG60NwcAAADtiOoZjrKyMvF4PCYLL5ROr1q1qt31Kisrpbi4WBobG8Vms8kjjzwiJ598srlPA36Bx2j9mIH7WtPH0SGgqqrK3OoBvjnI72T6mOZHQBc8dldJOWSCNG5aacanpW+X39VkyxdbKqSyrlEynPa4bntnoe20PZEkarsVbU+8tidae7vLhEG9pHeW02S2tHfeVIN1Uw4plK3l9bJ5T52UVEXODnR5vLK+tNYMkeSmOVoyA0ODgrmpUpTpJKMBQKfQPvlKqxtlW0WdbKtokO0V9WbYVl4v25rHqxr2Xa641uWRpz/c1C3bDBxoJj4AAACiIyYva87IyJClS5dKTU2NLFiwwPQJOHjw4DalPzvqnnvukTvuuKPN/NLS0i7pB1BPDmrgUk+MamZjLPAVDAmOHyMb5HdyiPnR+vYXG+TYIdlx3fbOQttpeyK1PVHbrWh74rW9uro62psQlzTQdtsZh5hSdhpyCw38BUJwv/n+YWEl7hrcHhMA3LKnzgQBA0Ngus7lifhcu2tdZli6pW2WoN1mkb45qdIvJ0XyUixyUHGNDMhNCwYJ9+fiJwDxrbaxyR/EMwG8huB4IKCnFzE0xVv6VxfQxDr9nLdY/LmM/mn/zNDpwHLW5pHgOhHWN2u0s74uF3hefazAfOX1eiTJluSf12p7mlcLnx/62GHLd7A97Ty2XnvSofa0eez2tqHt+hrM++/q0k7PxAcAAEACBf3y8vJMpt7OnTvD5ut0UVFRu+vpicShQ4ea8TFjxsjKlStN4E6DfoH19DF69245CaTTumwkWl5UA4ehmX79+vWT/Px8yczMlK44KaoH2fr4MXNStKBAdhYPFde2tZLfUCp9pEq2S6Z8Vdok35tUEN9t7yS0nbYnUtsTtd2Ktide251OTn51FQ3oad9V2oeQlhQLKMpymoBg6z6tnHabDC1IN0NrGozWwF4wCLg7PCi4o6ohWP4tlNvjkw1ltWYwloWfEM1JtYf3IRiSKaiZikm2xHkvAPHMq1l6NQ3BAF5Lhl5zxl5lvVTUuQ/48fUCg95ZKZKWbJOVO/Z9McmdZ42UUcVZewlEhQawwgM84QGj9tfX+0z/7rt3S35+ntj0uz1CwKxNIGsfjx0aWAsPmFl63HHNrl27pKCgICGOa/Si3sn3vttuhr2l+ftXM/EBAADQc0U16OdwOGTcuHEmW2/atGnBA2udvvLKKzv8OLpOoDznoEGDTOBPHyMQ5NMg3scffyyXXXZZxPWTk5PN0Joe2HfVwb3+oOnKx+8KqYceaYJ+6jvWzfKC91BZtK5sv9sQi23vLLSdtieSRG23ou2J1fZEams0aGDv5EOKTB9CmoWgGQZ6wnF/S27qazMvPdkMY/vntLm/scljTuCHZgb6h3rZvLvWlNOLpLzOLeV1lfLl1so29yVZLVKck9JuUDArhSxBoKeoc2mWXkjJzUCGnskerpFdNW5zEcCByk61S5+sFPOZUJydIn2yndIn2z+ug342Wa2WDgdeLpo4oFtKD+tv7SSXQwoynXzfxbmOZNjr/ZS8BgAA6NmiXt5TM+xmzpwp48ePlwkTJsjcuXOltrZWZs2aZe6fMWOG6b9PM/mU3uqyQ4YMMYG+t956S5599ll59NFHgyd0rr76arn77rtl2LBhJgh46623Sp8+fYKBRRyY1EMmSsXbz5nxU5K3ygv1h5q+cfRHsf5gBQAA6Ap6gnHSkNwufY7kJJsMzk83Q8QswZpGWbp2m9RIcrAPQX+A0J/hEylLUMv4bdpdZ4ZINOgX1odgyNA72yl2sgSBTsvSK6ttbCm5GdKHnr5/df6eWtcBP74G+DUQFwjg6W8jE9AzAT5ncwZfx356E3hBLGXYx6OHH35Y7r//fikpKZHRo0fLQw89ZM5VRfL444/LM888I1999ZWZ1ovaf/WrX7W7PAAAQEIE/aZPn276zpszZ445qNLsvPnz50thYaG5f/PmzWFXFGpA8PLLL5etW7dKSkqKjBgxQp577jnzOAHXX3+9We7HP/6xVFRUyOTJk81jUn7r27HnFom9aIC4SzbJAHeJFEiN7JJ0ee+bUrlgQv9obx4AAECX0IvKeqU55NDeaRHLvLmavCaAENaHYEj50JrGpoiPW1nvluXbKs3Qmp7Q10yg9oKCGjDsaaXw4klTRal46vwlFrW8oXdPubiaasTSvO9tqRmSlJ0f5a1EaH+e/gw9Lb9Z11Jyszlbb0dFg7g83gN+/Ixkm/TtlRoe0Au5zc9I7tQg3El9k+TJ0/Llj/9bL2U1LcHIvHSH/OTYwTK5b9R/xiMBMuw/Xl8ma7eWytC++TJxsJZ3jf/vnJdfftlcmP7YY4/JxIkTzUXpU6dOldWrV5vv/9YWLlwoF1xwgRx11FHmfNO9994rU6ZMkRUrVpiL1wEAAKKhR/xa0FKe7ZXz1IOoUJrBp8Pe6AmQO++80wzo/Gy/ypJNZvxYyyb5q2+k3PXPr6UwM1lOGOEP1AIAACQSR5JVBuWlmSFSlqD289VSLjS8fKgGJbwRsgS1xJ9mEerwgexuc3+GM6lNudDAuAYidJtw4AG/bXOvEmkK758trBfyJLsUX/07An/dINAfZ3iGXks/ejpP7z9QGsgoynSGldxsydJLkcIMh9RXlXdbv26B19+gJrf8uvUvdk28+rfItnd5/aFr6fviyMG5MjjdIwUFuab0bCJ48MEHZfbs2cHKUxr8e/PNN2XevHly4403tln++eefD5v+85//LK+++qrpbkarVgEAACRs0A+xI3XkkVL57l/Emp4lg+xpIqXa/4VHfvT0Z3L7mSNlxqSB0d5EAACAHkMvRstJc5hhdL/sNve7PV4TvIgUFNSyoNUNkbMEdf6K7VVmaE3PzWo5wWBQMDc8KJiTSpbg3pgMv1YBvzaa3GY5gi6dk6Wn/dcF+9ALydALBPcam75Nll6SCeD1idCPno4XZCRL0l5K6WqfdvVt32ZdhtcfEB0ul0uWLFkiN910U3CeBvpPOukkWbx4cYceo66uTtxut/Tq1avdZbSbGh0Cqqq68QMGAAAkBIJ+2C/2gr5S9JNfiqN4iPzQI/L1X76UN5fvMFeoz/n7CtlYVie/OP3ghCj9AQAA8G1pv30DctPMEEllqyzB0KCgBkU0I7A1nRUIoCxe3zZLMD05qTkI2BIYDAQFNTii/RvGO6+rUXxuHVzBW6+5bRTXzs0deoyazxZIQ+YX/p7WWgdRLRbJmDBFrM7U4KzGbeukYcMK/91mneDCwXWUNSVd0g8/Luzh6lZ9Jp6KsojPE3wMi4ijsL8k9z8ofDuXvNvqeUKeN+TxnEMOlaTMlr4zm6rLpXH9V+L1+cRTVSW1JVn+TLcI260XBoYGkl0lm6RpT4np67LG5ZE9NS6TjbenztUyXuuS9XU2WVwXHgw/THZKisVt+rLTkFZec9taXukWM77VlymllnSTpafBu36ZdhllKzMlMPMykiUvPVly05MlzZEU/nezNImjd65YHS1dP3hqKqWpfGeEv5NFvD4t71ohLne1WO0OcRQNCNvepvJd4m1o7rcz7HnC943VmSZJmeGBAPfuHZrKGPacTbqfAXS7srIy8Xg8wa5mAnR61apVHXqMG264Qfr06WMChe2555575I477vjW2wsAANAegn7YL/pjPrnfcDPutIo8dMHhMiA3VR5ZuM7Mm/fBBnMS6vcXjJFU/YENAACAA5aVapdRqVkyqm9Wm/uaPF7ZUdnQblBQy4pGon0MrtxRZYbWNE7RO9MZ3odgbqr0zXZKitct+SZA0XVlHH1NGoRziS8kKKfBOPF6xDloZNjydauWiGvbOv9yTa7mQF4giBcYd4lzyCjJOeWSsHW3PXCFeGvb9qW4P2o++fde7087bHJ40G/jSqmY/+w+H9eeX9wm6Ff90XxpWPvlPtfNOOr0NkG/3X97VDqiYMbNYUE/d8lmKXvl98HpPXtZd9ulj8j2ysZgCc7D1r8lk6uWBO9PbR76tVrvU28fWSxTwub93LZYBlsq9rm9luPOl94nnGoC56qpcrdsu/++sGVqmofWev/sARMgDQ2q7nn9sb0+n4YEbZm9pO/1fwybX/72c1L31b6zgNLGHi9551weNm/HIzeIr7FeDkTpC/eLLTVTLMkpYk12isWRYgKZ1uSUkHlOSRt9rFgdycH1vPW14m1ymWX1frJ+gc7x61//Wl566SXTRY3279cezSTUfgNDM/369Wv96QgAAHDgiMrgW9Ha/tefMsIE/n7xt6+kyeuT/6zcKef9cbHMm3mEFGS2f7ALAACAA6clCTU4p8PREe6vrHebAOCWCEHBreX15ritNY3pba9sMMPHGwJhHp84xCNOaZJsu0/ycjIlN69XS1AwO1n67/laejl8YvO6g8G2QPAtNBiXM/ViE9QKDbbsfu2RYJCuPRrE6H/rM2Hz6ld+KjVLFuzz72TLaVsC0WJ37HO9ROfzdbyk5oV//jg0hVDyrPUiHej+TvueHFuU3VJyU/vRWzRfpAPx2OwURzDgl4g089Nkf+5D6qGTRKQl6Ff10b+kcsHL/gmLRSz25OZAobM5EKgBwxSxF/aXnCkXhj2Wvl81SGmCirps8FbXTfEHEbuh30OgK+Tl5YnNZpOdO8N6cDXTRUVFe133N7/5jQn6/ec//5HDDjtsr8smJyebAQAAoKsQ9MO34qmtFEuSQ6Yf0V+Ks1PlsueWSHVjk3y1rUqmPfyBzJt1hIwoyoz2ZgIAkHAefvhhuf/++6WkpERGjx4tDz30kEyYMCHisk899ZTMmjUrbJ6ekGpoaJBoaqoo9fdv1Q5bakZC92mlmXEqNFNHSzJquUHNlLO7G2WQ2yUDNaCW7BJvXqP4slzi69sokpIhtaNODssMHP7V3yS3eotYPC6xe5skWXTwSIolpF9Bn8izZYfJn3eNDc5ySJO8k/ScdKRXosyjvhsW9FPevezj4NO6Gkx7Q9vaocCdLclfSrMVzRr01lWZgIcey1ocDn/ww54snvpaqfl4/j4fOvvUS8WeW9hcnjF0Y/3T1tSMsNkpB40TW3Ze+PLB8eZbn5iAS2uZx5wlaaOPifg8ZiVfSyn+1nqd9ZOwxw+MaKZodYNbKupcpozsO2uaZN1Xy2Rbcz96+joa65nYXEzTLzAeUriy+UHD/8Yf+vpJlaRJdkqSZKbYJdOZJFlO/3iGGbdLWrJNTswtlDNHh4esq63fFU9tVTt/n5ZtcfQbFraeZrZlHjutnf0R3n797AjlKOwnGZNOa7Wcf9zn9UldfZ2kpqSYEp2tOYccZkqyRnoeHQm8T50DDm6zbtqoo02WamjbPHU10rBGy8bugz1ZRNfdR/ZtaBlT8zShmYWaXetqEI+rQaTV2zBYsjRE5buviGv7+r0+n76Psk74vmQdc1bLY7kaTMapCQwGgouhgUMNOposRafYC/qHZSYC3cXhcMi4ceNkwYIFMm3atGCfnjp95ZVXtrvefffdJ7/85S/l7bfflvHjx3fjFgMAAERG0A8HpGHzaql450Vp3Pi1ZBx5quScdqlMHpYnr15+lMx68lPTh4xeIf69RxfLwxeNleOGJ+4JOQAAutvLL79sSkc99thjMnHiRJk7d65MnTpVVq9eLQUFBRHXyczMNPcHRLvkmwb8ts29SqQpcolKI8kuxVf/rscG/jz1NSFlKhvFG1q2UstYuvzZb8mDRpqgQ2jby//9fMQyl6F90Olt3xv+JLaMnOC6tUv/JxVvP7fPbbMX9pO+x54lfXNSRYb45+3c3iQN5aX+ib3s/tTQIKD23yYd7wPw5lc+k6qiumD50OFNLinOKhC7CQQkm0Ce/7ZtME4088zS8lzpR5wkKcMP9y/bvK6uE7a+LfK25Z17Rbvb2Lh9fYeCfs5BB0tyn8Edbrs9r7cZDkTKkFH7tbwGmqrqm/zH5Gmj/LfN/TwGbndVu8Xn06wsZ/Owq9WjpMpGaRuoCijISA5m6P04J0X6ZPn71gvMy061H9DnSMbEqXIgNCCXM+WiA1pXuy8IdGHQmp70d+/aJTkFBf4+DVvJOKL9vrv2JXeaBmTbvv5KOhD0K5p9pzh6D2r+nKgXb2O9CeB5GxtMYE8Dbfr5YbGF/+TXwHDKwUeIr7FBvK76lmWbp8Xrz/DUAFxr5v590M8liyX87+RtqJW65R9KR/S+4j7TroDaZR/InjefbMkoDAYIWwKFmp1oS8+WzEmnhj2We89O81nbEmRMafczAVB67DRz5kwTvNMLpfT4qba2Nnhh1IwZM6S4uNj0y6fuvfdemTNnjrzwwgsycOBAc6GVSk9PNwMAAEA0EPTDAdEf8I0bVpjx6sVvSdPuHdLrzNkyvDBfXr/iaPnRM5/Jl1sqTJ8xP3jqU7nzrJFy0cTwTu8BAEDXePDBB2X27NnBk1Qa/HvzzTdl3rx5cuONN7b73b6v8lXdyWT47S3gp5rcZrmOBv1Mxk2Tu1XwrDkYp6UlPU0miBSqbuWn0rh5tSlR6a6ulN02a3PAriV4p+tr5ljumbPD1t3x0LXiqdq9z+3qddaPw4J+ui11yz7oUJv0uW0HULZSA46tmXVttmCQzQTRzK1/3O0VSU7PkB8NHyvnDzkyrFzou2tOltI6r5TUeaW0QaRRbNLgS5JGSZIG0VubGa8ud5gMsnCnBYNIplxour9kaaA/Qb3NT08WizU8gGT6ZAvply2RuD1e2VmlGXkNsq2irvnWH9AL9KtX6/Ic8OM77dZg8E6DeVl2rwwrzpXinFQzryjLKclJBE+iTT+3NeAtjmQT9OqI9LHHm2Gvn5Ea3IuQQJh94nTx1FT6A4UhQUZ/8LDlNvRCBPO4jR3PGtcAXihvfY3pf3NffXDasvLaBP20D826r7X0bIgke0vfh823qSMnSubRZ4QtVvXBP8VntYqnwS11ZQVic6aGBw8DGYtJdoknoRn2Pq9XvHvKxdVUEyzbGu8Z9tOnT5fS0lITyNMA3pgxY2T+/PlSWFho7t+8eXNY8P/RRx8Vl8sl3/ve98Ie57bbbpPbb7+927cfAABAEfTDAXH0HSbpR5wsNZ++Y6brv/lCtv/+55J98kWSN3GKvDT7SPn5y0tl/ooS8Xh9pr+/Tbvr5Popka+gBQAAnUNPPi1ZskRuuumm4Dw9QXXSSSfJ4sWL212vpqZGBgwYYLJaxo4dK7/61a9k5MiR0tNVvf93c+K1JZDnkpxTLhFHUcvFRnWrl0jZS7/1l9HbWym8JLsMuP2FsFn1a5ZKzSf/bnmsdlb19PKfEAylWWod0bovu4iBOy1TqVlwrYNxrTKpNEMm46jTWwJ3gQy4VoE8q7NtCcn8C69rtz8ufV3s2rVL8pqznbR4uwaFjhyc619gykHBZWsbm2RLeZ1s3t0SFNTbTXvqpHZPvYgncl9xu6obzfDZpvI29yUn+fsvDPQjGD6eIqmOzvtZY0o/6on8fWSZti4R2ZmqGtzB4J0/M89fcjMQ2NOAX4QuGTssLz1ZirOdLYG9kAw97VcvJyRLL7DvC9rJdEPniubrz+xzu0Ns7Vw8oOVID0RSr0Lpc80f/EFCk1UYKTPRP21LC2+XBtVs2fnNy+rnR3imcUCksrj6XG1oUFOHkLLCjlYZuxr8LH/72WDW494u3ci/6HpJPfiI4LRrxwYpn/9cSz+JgeCiCRSmNGcm+udradjQz1yf1yNisUYt0769DPudMZRh3xm0lGd75TwXLlwYNr1x48Zu2ioAAICOI+iHA6I/RHLP+rGkDBsje/7xZ/FUl5sr3svfnCe1y96X3GmXySMXjZVfz18lf/qfv98Hvd20u1Zu+k6faG8+AABxq6ysTDweT/Cq9ACdXrVqVcR1DjroIJMFeNhhh0llZaX85je/kaOOOkpWrFghffu27SNMNTY2miGgqqoqGCDQ4dvSDIOOiFQyrqnqdEkqCMmc057I3C3butfMwaamsJOwGiDbq+bMOLHZ27RbT+h6CvuHZctZA2UnNfjWXIZSTziHrmtJy5beP3+oJbi3lzKVKnRdR7/hZuiISPupvb+7Lqsnwjuyb1PsVhlekG6Gto/jk53VDbJlT31LQLC8PhgYLKtpm4GoGpu8snZXjRkiyUt3tAQDc1KCQUENCBZmOMXaKktwb6yZudL7/+aaPv80PvnVtgrZWlouffNz5NDibLFZtb++TLPcgbzWtS89DW76A3gNsr2yvlWmXoOplnGgHEnWYKlNf0CvuexmltME9HpnOiXZvvcsPd3Xgb7o9mffx6Pubn/o66/dZb7F6y8q7bdYTeBuf54zIPXw75ghwNfU1Fy6tDlwqEFDDe5ZrW0/g4eONlmHLZmIIaVPm29NgEsvHAlZVzOoAwG/fUpyhK3rrtgtDeuWdWjVvre/GFZJuXz+s1Lz0fxgydLQ8qXmtrkfRHvvgZI+7sSwx2rc5P9+92cg+tfV5TVo2tEgYlNNZYcy7HU5ff19W4n6mQIAANDVCPrhW0k9ZII4B480/c7UfOLP+nNtWSM7HrlOso49W26aco454XLbGytMxt/bK3bKlrJqefIHOVKY1fZqTAAA0P0mTZpkhgAN+B188MHyxz/+Ue66666I62h/NnfccUeb+VoWq6Gh46Xc2qMlxQ5UedkusWW2lJD0NrjFktvHnz2jAbTmWzNoYM1mN7d6/66dO8MCbN5BY8ReMEi81iSpaXBJRk4v02ecf327WKz+ZfXUpWZDhTniux3a3lqNrbReV5kMwMhBsO6mJ2c1IKwn/79ttpf+xQam6eAQ6acZRS1lCevdHtle6ZJtlY2yvbJRtlU1Bqd3VDZKoydyepsGC3X4fHNFm/scNov0znRIn6xkKc5K9t9m6q3DTKc6IgfA/rvRLb9duEV21QROgu+UgvQ98vPv9JPjh3oj7zPdny6PlFS5ZGe1S0qq/bc7mqd1KK1xSTvN6JCclCQpzHBIUaZDijIcZlwHbaPe6v2RT/J7RTy1UlleG7V9H4ui1v6kvfQH5mr/9dfZevT+tzhFnDr4J6ta/02GHuEfAos3D6Gt8Hk80ij+bNbQeUmn/cgECuurKsSZZBWLXjiiGeUaKAwZr3B5xBqyrqcsLC+uffZkKS0rC5vlrigX8XrEW18rokM7rINGSV2/8H4+G195SKQq/PH8jbaa8q/6fBa7U2wTThHbsHEtba2vFc/n75jAp6+xvVz2cHv2lIs16du//qqrW7ItAQAA0HkI+uFbszrTJPfMH0vaYcfI7tcfk6ay7SIej1QufFVSDhorFx85zFxtfcXzn5urlr/eWSfnPLpYnpx1hAwv7LqySAAAJKK8vDyx2Wyyc2f4iUed7miffXa7XQ4//HBZu3Ztu8to+dBrrrkmLNOvX79+kp+fL5mZWvzx29E+hDpy6jTnnMsluc/glow4k0HnDC9TWVAgMqrlxO9+0XWbT3xrQFPb1+NOfHcDbb8Gkrqj/QOK29sGn5TWNDZnCDZnCmoZ0T3+TEHNnovE5fHJpvJGM0SSm+YwGYH9clqyA0sqG2TuAn+1ilClNW656Z/r5dqTh5vltlc2+EtwNmfraaZeVcO3yNLTAGVWoNxmc4ZetrOlBGeWU5z7yNKL5X3fE9H+BG1/794H9Lnvy5sqvnHHtZQvbc4yDGYYBsqU+nyS2fz9ElBZWCz15QNNBR3/+jq0/dxyZmRJbqt1t3nc5uKTthvkFdHn08cTkYwUp6SHrOvauVl2frFA9kevXjniaPX8B8KpAVsAAAB0OoJ+6DTOgQdLnyvul8r3XpPK/70uGUecJMl9h5n7jhueL3+9bJLMevJT2aEnRyrq5dxHP5RHLxonk4flRXvTAQCIGw6HQ8aNGycLFiyQadOmmXl64lKn2+ujpjUtD7p8+XI57bTT2l0mOTnZDK3pidHOODHcXt9ybbajaIAZuoOe+O6s9sWiaLdfn7Z3dqoZJoZ3wWXUuzyy1QQBW4ZA2VAdGtyRS8ntrnWZYemWyn1uQyBB7zfvfHNAbdC+8rTEZp/mwF4gmGfmZTslLy15v0qRJsq+jzban7jt3++263KapZm6l0zNduSceJ4ZWpdcDusL0dVg+gNsvT2Zk04Tb32NCRYGy5m2CjzqtM2ZGrauyWA8gO/nzngtJOLrCQAAoDsQ9EOn0qvrs086X1IPndSmc++DCtLk1dOz5Af/scqqXXVS3dAklz75ifzy7ENl+hH9o7bNAADEG83AmzlzpowfP14mTJggc+fOldraWpk1a5a5f8aMGVJcXGxKdKo777xTjjzySBk6dKhUVFTI/fffL5s2bZIf/ehHUW4J0HEpDpsMK8wwQ2tamlCzBINBwN0hfQruqZOSqm9fktYezNIL7U+v5Vbnpzr4+QVg/wJsFg3UOVP3ulzWd845oMe3F/STwh/eboKJ7pLNUvHOCwe4pQAAAOgp+NWJLuGIcMV99cf/Fveb8+SxwaNlbtbR8vqaOmny+uSGV5fLxt11ct2Ug3rklc0AAMSa6dOnm5Jkc+bMkZKSEhkzZozMnz9fCgsLzf2bN28Ou8K+vLxcZs+ebZbNyckxmYIffvihHHLIIVFrgy01w98HX1OgP7UIkuz+5YAOZOsUZDjNMG5Arzb3N7g1S9BfJvTNZTvkr59v3edjnjm6j0wZWRgM7OWlJ4uNY1kAMUSDic5BI814Y0aOCEE/AACAmEfQD93CU10uFe88b8Yt67+Ua5xrZcKwE+XmNTmmO/VHF66Tzbvr5IHzRnd7PyUAAMQjLeXZXjnPhQsXhk3/9re/NUNPohUDiq/+nXjqqttdRgN+rSsLAAdCjz+HFqSbQcc7EvS7YEJ/mTQkt1u2DwAAAACAjiDoh25hTc+W3LN+InvefFK8ddXia6iVoze8Ia8XDpGf7RotW3yZ8ubyHbK9sl4enzHeXCkNAAASmwb0COqhu00Y1Et6ZzmlpLIh2IdfKM3lK8pymuUAIF6QYQ8AABAfCPqh20oqpY0+RhyDR0nJ638S7+pPzfyc3evkGcdmeco7Wp5zHyJfbK6Qsx/5QJ689AgZWsCPCQAAAHQvLdF52xmHyGXPfW4CfKGBv0DxTr2fUp4A4knrDHuf1yt79pRLr145pm9BRYY9AABAz9fSmQvQDWxpmWI/eYbkz7hZbM0/Fqwet/zA95k8YX9ThkuZbNlTL+c88qF8uK4s2psLAACABHTKob3l0YvHmoy+UDqt8/V+AIg3GtBL7jPYDI4+g8Va0M/cBuYR8AMAAOj5yPRDVDiHjpY+//egVCx4Wao/fFPE55NBvt1yYfpmub0mT6oammTmvE/knnMOk++N6xvtzQUAAECC0cDeyYcUycfry2Tt1lIZ2jdfJg7OI8MPAAAAANBjkemHqLE6nNLr1JlS9JNfib1ogNgyc+Xc/7taThhRYO53e3xy7StfygP/Xi1eb6QeVQAAAICuowG+IwfnypQRvcwtAT8AAAAAQE9Gph+iLrnvUOl92a+lqXyX2DMz5E+XjJO7/vm1PL14k4y3bJen322Qv3y2RY4dli/HHZQvk4fmSXaqI9qbDQAAAAAAAAAA0GMQ9EOPYLEliT2vjxlPslnljrMOleGpLhm38DlpkCT5T80g+fLzIrl5SaHUWJwypl+2HDe8wAQBRxVncdU1AAAAAAAAAABIaAT90GNN2fOe1FmaJEWa5PuWlfJ9WWnmr/dly9KtRfLFliJ56j+FIqmZcoxmAQ7Pl2OG50lBhjPamw4AAAAAAAAAANCtCPqhx8o57VIRn0/qVnxkbgMGWyrMcI6sMtOfNvSRa7+cIm98ud1Mj+yTaQKAOowdkCN2G11XAgAAAAAAAACA+EbQDz1WUkaO5J9/jXjqa6Rx0ypp3PC1NGz8Wlzb14cFAattqSLelvVWbK+ScTvelyfeS5cb7cUyfNgAUwr02OF50jcnNTqNAQAAAAAAAAAA6EIE/dDj2VLSJXXEeDMob0OdNG5eLQ0bVpgg4DnjT5aRvUbLe9/skve+KZX128rkUutSsVl8Jhi4Y1W6LF1ZKL/0FUl5r8EycsQQOfagApk4qJc47bZoNw8AAAAAAAAAAOBbI+iHmGN1pkrK8MPNEDBBh0G95LqpI6Rk6SfS+NeWTMDelhoznCrrRCo/kF0fpcrSxUXyN2tvqR04XiaNKJZjh+fLwNxUSaIUKAAAAAAAAAAAiEEE/RB3CkaOFlfmbdKg5UB12LJaLJ6mlvstdTLFsl5O8q2XM9b2l3fWVgbvO9G5Q/o43GJNyRRbWoY4MjIlLTNbMrIypFdGiuSlOaRXukN66W2qgyAhAAAAAAAAAADoEQj6Ie5Y7cniHHyoGZSvyS2NW9eaAGDtuq/EteUbsXpcstmaKzWe5LB1p7i+kiObtonUicjulvlNPotUSbJUilO+kWRZ4B0kf/eNkOxUuwkA5qY55AjfVnGkZ4gzM0vSsrIlKztLctOT/fenOyTbydsNAAAAAAAAAAB0DaIQiHuWJLs4Bx5shuzjzzVBQNf29VLgapC30webvgA/3VgupdWNkr/TbfoBbC3J4pNe0mAGtdxSIOITqahzm2FzaZX8JumVsHUCgcKdzYHCSp9Tamyp8mHG4eLJ7i15GcmSl+6QvDS75Kc7JS9Tp1sGRxJZhAAAAAAAAAAAoGMI+iEhg4DJ/Q8y4/r/QUUZ8uNj/ffVf5MqTeW7pLG6UuqqKsVVVSnu2irx1VeLtaFWkly1Yve6pCA/T8Y4smVPrUt21zRKsktTA/ceKBSLph2KvLlnkKzY4wguN9mySW6zvie7JVU2S6p84UuRMkmVmqR0cTuzxJeWLdbMHHFm5UpWdqYJCOabgGFyMHCYnGTrpr+eiE9LpXq9Ikl2sVi0UQAAAAAAAAAAINoI+gEhUoYfbm4z9rKM190oPxSR2faW0qAaINy9qEnqqyrEXVMlnrpqsdTXiM1VIw53ndi97uCyVUnpIi1dDEqe1IvD4pXeUmMGExw0T6QP3DyUipT7nDLNc37Ythxv2SD5Uie19nTxpGaLJT1bUpxOybR7JMPmlTSrV9JsXvFk5IlkFUhqcpKkOmySZnFL/ur/ikOaJMmrg9sMVo9bLE0u8bkbxdfkEq/bJQUXXif2/OLgc9YufV92/+0REYtFLA6nWB1Oc2txJAfHrTruTJPcsy8L297GTavEU7nb3B9Yzr9u4HGSxWJPJpgIAAAAAAAAAEAsBv0efvhhuf/++6WkpERGjx4tDz30kEyYMCHiso8//rg888wz8tVXX5npcePGya9+9auw5S+99FJ5+umnw9abOnWqzJ8/v4tbgkTpM7C11MwsST3tgnbX8boapammUsq2rJf/HjxWGnxWKatulLKaRnEvc0vNyk1ir6+Q5Kb6dh+jTFLazDvVskYmWrf7A4Q1zUMEj3vGynO+w4LTmdIg/0h6MzjtE5GWsGS4q575UErTiiXV4Q8Yjq7bLqealXzia6wXT2PkbfY6UqVk4oWSYrdJcpJFahqaxLLkXWlY+p7slcUiqaOOlvzzrgqbvev5+8TnahCL3eEPDCbprcPsj+A8u0NSho4We0Hflu1wNYh75+awdYKDThNgBNrwNtSJp7rcBP/N+yQ5RazJKf4gPe8ZAAAAAAAAoEeKetDv5ZdflmuuuUYee+wxmThxosydO9cE6FavXi0FBQVtll+4cKFccMEFctRRR4nT6ZR7771XpkyZIitWrJDi4pZspFNOOUWefPLJ4HRycttADdBdNKMtKTtPrC6vWJOSJN1qlfTkJBmYlyYycJrImdPMcj63S5qqy83JdjNU7ZGGit1Sv2e3FCdnymMHjzOBwsAwaJlbxLXv50+2NPkje80aOvDWd/us0iA22VxaLV+Vlgfnb5FG6W0rFKc0SYoZ3MFxu6WlQ8SyRpHv/35R2GPebt0kx++rq0KfTz7bXCX/e22ZWC0WM9isFrnwm68k2dN+UDTgvVHTZWefscH1Mqu2ydhFc9t/OotVfBab+KxWWTb1VnHbU3UTxOvzScGGD6VowyL/MlabeM2yVvFa/OP+wSY1qfmyaugp4vX6xNu87pAtH0hKQ4V4LFZx+SySnJEpScmpYnM6za09JUUcqaniyMqVlOxekuKwSao9ydzabRYCKwdA3z+ehlrx1tWIt94/WFPSTX+eoSoXviae2gqxpWWLLSNbrOlZYkvP9g9pmaYEcE+nGcfe+lrxuRpNMFyD20m9CiQpMze4jKe2Sqo/ftt/v2bvuhrM8ma8sUF8bl1P5zdK0U9/GbZuzZJ3pfxf4RfPGIEM3+YgoC07Twpn3hK2iGftF1K1ql5sKWn+ZZ2pwVuT0Ru47WAA0aflhL0e8Xk9Ih7/rQlAhuwnDVI2le8Un8fjX7Z5ucB6Fos1mMkNAAAAAAAAxKuoB/0efPBBmT17tsyaNctMa/DvzTfflHnz5smNN97YZvnnn38+bPrPf/6zvPrqq7JgwQKZMWNGWJCvqKioG1oAdB7NPrP3KjRDQGbI/eGhC5HGsVdJU3mpCRA2Ve8RV8UeafJ4xGO1i1sHS5IZjus1RA7NHSJ1Lo/UNerQJP8tvURqPTap8VilxmORqiarVDdZpcJtkSq3RWrcPql1NUm9T0+ct0QMv5JCucpjcv3aSBJPMACYZNIPw/3TN1yWeTRg6JYUS5NZNjUkaKi3TotbPtxtkxfLtoSte6HN1VL6dC/+snSXvP/FyuD0KNkpY/fySWfxec2gm3vz37+WOmnpb3GWda1cat25z+dc4cuX+9cNCpv3iO1TGW4p3ee6z3lHyePeccFpLbn6ku1VabTYpcHiEJfZlw5psjnEk5RsBp8OdqdsLhwtvvRekmq3aSxGkhprJK1utzRZbOKxJvlvLTZpsvjHdfCKDv5dGghuKr0NTOscn89num7UqcCy+hxWM/iDkoFxvfVPN8+zWsyuaqivk/S0ChN8bXN/yLqhj2e3anldl6RLg6R4GyXV2yhOn0uSRkw0maaaOaqBUdeSd6Ru+YfB4J4Ovqa2+aopB41tE/Sr/epDcZdsanefaKBQg4GZR58h6eNOCOvPsmHd8uZAYbbYUjPFYjvw/jQ1MOXVIGV9bbANmlHnHDAibLmy1x6Rpt07wpaL1Nac7/5AMo9seW96G+ul8t2/dGxbGpv7Hm2mpXYjL9iS4evRyaaQWsWB5/3mM6lcv2yfz6l/29ASwPr32Hrv7GC/oT5vc/+hza/RUAWX3iopQ1uylxs2rZTSZ3/d7nNZUzOk383z9rlNAAAAAAAAQCyLatDP5XLJkiVL5KabbgrOs1qtctJJJ8nixYs79Bh1dXXidrulV69ebTICNVMwJydHTjjhBLn77rslN7cliyFUY2OjGQKqqqrMrdfrNUNn08f0n1Dv/Mfu6Wh757bd3neYGQ7M0A4v6WrySp2ryR80dHmk3u2RepdHGvS2eWhw+5epd3ulwRU6379OZU29eCw5skbvd4c/Rp3bE+m8fphTPRdJsjRJsnja3lpaplf58sLW2yMp8lfvwRHXc1g0OOkzAUoNhTVJeBqix2eVOl+S2MRn7k+yRN5IT4RopD+0tm91vvCsMg1+5lo0o7Hen53paR4i1F99akuKrJL84PRJlvVyq+1/+3zOMl+KnOuZHjbvB9bPZYJlu7hFMxNt4hKbuCVwazXjujkrfAXyb9+QsHVvtb5nttsfUvT/rWwWX/i0+OQR73j5zNeSkT1CyuTXtv+ELee0aGPbOuGtOvGE7J+fWD+TC60twd32bNxaKk+8tVJS7FZTolYDhpPK98jecvkCgTWPZsWFvF+bKvfIrmd+1bKgBipTM0yGoDUtywQDbWlZYknLEm//Q8XrbXkt1ixZ0BykDAncRSiN6xw6Whwzbg6b17hljTSVbt1nW72NDeGfL/vKWLTa/H1x2pPF0+QWW8i6Sbl9JHXMsaa0p5b41G3VIGLYrZbbdaaEPaf5nGsVQGyXI3xdfX1566o7tKrX0xTeVsveU4g1kNiV3zuJ+J0GAAAAAACAnieqQb+ysjLxeDxSWNiS1aR0etWqVR16jBtuuEH69OljAoWhpT3POeccGTRokKxbt05uvvlmOfXUU00g0RYhK+Oee+6RO+64o8380tJSaWjo4MnL/Tw5WFlZaQJAGuRMJLQ9ttue1Jx5mKmxhGA8QdsSaE/yXtuelZUVse36N3F5fNLQ5JVGDQrqbZM3mHnm0VstnWkeq6WEpt56vP7MNL3VeScF7vNq0C6QvTbKPIZOV3tFKs26/vX9WWb+DLarJJC1Fpg/QD6QM1uWEZ9Ydf+JR2zmVoNVWjrQJvclp4VkrWmU5yJZ09Qo4nFLXVWVJFnEX4rR3ShihgaxuF2SlzZYTknuZYKl2mZHg8ju8nRJ9moGpDtixmRAfavQlcNEB/ctUsJkX6mWgy1l7S8QeA6vp03Q70jLVkm3tNcrZAvN4AvfDp/kWDr2GZsuLqkUZ3C6yud/rTX4bFIlyVIjDnNb7XNItd5KslT5HLK9KkPe/d/6sMcqkimSK/XSy1IvOc23vaRBejWP51oaJEfq5Ff/3SqrP3tf0hw2Mwz27JSwnjv1NVRbZYbW6s66RiQ5Nfh6b9q6UTzr/X3R7k1jdYXs2rUrbJ4nqTn7VG+1VGZyqnlszQoUh9PM1yzhurRe0hCyrmbOJX33p+Y+0b5ITT+W/lszWJOC5TUr9L/Q503NFZn8/Tbbp0vbWr13Q7dX3+v1o46XtFGTxdLkEmkuKWpu3Q3mVppLjTY4M9q01ZJd4H8DahBPv6/11mprHvzjFqtNKhvcUh36vE0WsR462SxvCVk2eJtkb/Ncnam6umPBSgAAAAAAACCuy3t+G7/+9a/lpZdeMll92r9fwPnnnx8cHzVqlBx22GEyZMgQs9yJJ57Y5nE001D7FQzN9OvXr5/k5+dLZmZoccXOoSdF9USrPn6sBn8OFG2n7YnT9mHBtusFBO21PXKh1Ja5Wj7R66oXd32dNNbVSYMZasVVXy8PFg43mYKaLamcu3tJxWaHWDxNYvU2iUUHj9s/7mmZTk9Ok1dOObIluKlBtQVfiW/9RhOI25upB+fLd06cHFYONPWpV0Qa2w/6aX+I2hfiT48eLBcNGOvPePWJ2Mu3iWvRR839Kvr7SPTY7OJKSpEGm1PqrSlSZ0mWGkuynJbVVyo8SSZrVNu7uvFI+YlrvClJW9+cYarZox1RIhlmCDY1YpN9YqkS8VXVBOcUSYO4rKP9wUGplxwTLPQHDpND+rNUZ71aKpJUIXarRew2q5zrq5IZzVmh2qZaq7bPP2hbG3VISpEqyZGV/9km9iSrJFkt4rBZJa3w+yJ97WLT8r82/+MFbjOcSZKVYpdMp10yU5Iky+4f1z5DtYyq9O4tMfVev+ahA3ti7QN4REu5z+4WegwCAAAAAAAAJGTQLy8vz2Te7dwZ3meWTu+rP77f/OY3Juj3n//8xwT19mbw4MHmudauXRsx6Kf9/+nQmp6w7KoAhem/qgsfvyej7bQ90XyrtjscYnM4xJ6eJan7XFgDPJMObCN/cIMJxonXY/qLM4PHLT53822TWzQ8aE1Nl6TsrLBVPT+f25we6c/C0uwqn1hkV1mZFBYWBds9KNL2HjO+Q5sXlmHXDs0CbWjyl40NLUMbCBT6y9P6y9TWNDZJdUOT1DS6pcbcBqZbxqsb3OLWFNFmGiic5z08wjP7TCZiTnO2YJalwZRFlSZvc26jR56XIfKiDJY6k525j84pt5XIt6W7QwN/YQHB4Lj/NislqWU8NXw57TsxkAW4/8+deO/1RGorAAAAAAAAeq6oBv0cDoeMGzdOFixYINOmTQtmCej0lVde2e569913n/zyl7+Ut99+W8aP3/cJ461bt8ru3buldzdnPABALDFBHluSWGxJIlo6soO0T7vIGV/dGwjRzDbtt0+HyD247r/GJk/boGBg2sxrCRrqrc6raXDLwbUNJgja5PGJ2+M1wUO9TfZ4zTyX3np9pixtV9D4rT9w2eTvH3I/aZahBgQ1AFiQkSzF2SnSJztFemc7zW1gWgOLAAAAAAAAAHqGqJ+t07KaM2fONMG7CRMmyNy5c6W2tlZmzZpl7p8xY4YUFxebfvfUvffeK3PmzJEXXnhBBg4cKCUl/oyI9PR0M9TU1Jj++c4991yTLah9+l1//fUydOhQmTp1alTbCgCILclJNklOt0lueuT+KiPRgKf2H1dQULDPDDDNTnR7m4OCTd7geJMJFLYEC1tuW4KG2gekBh2r6pukqsEtlfU67paqhiYzXm3G/fNDMxY7QgOSe2pdZthQVtvucpnOJBP88w9O6Z3lNP07jqhLkuKcVCnMdJoypAAAAAAAAAASIOg3ffp009+VBvI0gDdmzBiZP3++FBYWmvs3b94cdtL00UcfFZfLJd/73vfCHue2226T22+/3ZQLXbZsmTz99NNSUVEhffr0kSlTpshdd90VsYQnAADRotmJyVabmIS5LvqK0rKtDW5vq8BgYLzJTJvx5gBicLzBLRW1bpO92B4NMFaVVMuqkupW92zwt88iJvAXDAxmhYxnO03GoGYTHmgpUQAAAAAAAAA9KOintJRne+U8Fy5cGDa9cePGvT5WSkqKKfsJAAD8ZVtTHDYzaABuf2k24Y7KBtleUS/bKwK39bKtot7M31FZ324moVYv9S/TIEs2lUdcJtVhk2EF6TKmX7aM7pdtbgfmppmAKAAAAAAAAIAYC/oBAICeKcNpN8Pwwox2S5SW1TSaIOC28jr5ZluZVDXZmgOF/iDh7lpXu49f5/LIl1srzSCLNwXLhmoA8PCQQOD+lFgFAAAAAAAAEhFBPwAAcMA0I68g02mG0X2zZHyhrU1/hg1uTzBbUIODertDA4KV9bJlT51s3F3Xpmzo+2vKzBDQNyfFBP8Cw6HFWeK027q1rQAAAAAAAEBPRtAPAAB0KQ3ODcpLM0Mk2o/g8q2VsnRLuSzdorcVJnsw1NbyejP8c9kOM22zWmREUUawLKhmBQ7JT6csKAAAAAAAABIWQT8AABBVWSl2mTwszwzK5/PJ9soGWbq5wgQCv9xSKcu3VUq92xNcx+P1yYrtVWZ4/uPNZl56cpIc1jcrWBJULG7MYwAAHsJJREFUA4GagQgAAAAAAAAkAoJ+AACgR7FYLFKcnWKG0w/rbeY1ebzyzc4akwX45RYNBlbIN7uqxedrWa+msUk+XLfbDAG9s5zBbMATRxTIsHb6JgQAAAAAAABiHUE/AADQ4yXZrHJIn0wzXDixfzDI5y8L2hIILKlqCFtP+xLcUVki//qqRJxJVoJ+AAAAAAAAiFsE/QAAQEzScp6ThuSaIaBEy4JqEHBrhSkPumxrhdS6/GVBx/TPieLWAgAAAAAAAF2LoB8AAIgbRVlOOSWrSE45tCjY99+60hoTADy4N1l+AAAAAAAAiF8E/QAAQNyyWS0yvDDDDAAAAAAAAEA8s0Z7AwAAAAAAAAAAAAB8OwT9AAAAAAAAAAAAgBhH0A8AAAAAAAAAAACIcQT9AAAAAAAAAAAAgBhH0A8AAAAAAAAAAACIcQT9AAAAAAAAAAAAgBhH0A8AAAAAAAAAAACIcQT9AAAAAAAAAAAAgBhH0A8AAAAAAAAAAACIcQT9AAAA4tDDDz8sAwcOFKfTKRMnTpRPPvmkQ+u99NJLYrFYZNq0aV2+jQAAALF8/PTKK6/IiBEjzPKjRo2St956q9u2FQAAIBKCfgAAAHHm5ZdflmuuuUZuu+02+fzzz2X06NEydepU2bVr117X27hxo1x77bVyzDHHdNu2AgAAxOLx04cffigXXHCB/PCHP5QvvvjCXDClw1dffdXt2w4AABBA0A8AACDOPPjggzJ79myZNWuWHHLIIfLYY49JamqqzJs3r911PB6PXHTRRXLHHXfI4MGDu3V7AQAAYu346Xe/+52ccsopct1118nBBx8sd911l4wdO1b+8Ic/dPu2AwAABBD0AwAAiCMul0uWLFkiJ510UnCe1Wo104sXL253vTvvvFMKCgrM1eoAAACJ5ECOn3R+6PJKMwP3drwFAADQ1ZK6/BlikM/nM7dVVVVd8vher1eqq6tNzXc9iEwktJ220/bEkKjtVrQ98doeOF4IHD9EW1lZmcnaKywsDJuv06tWrYq4zqJFi+SJJ56QpUuXdvh5GhsbzRBQWVlpbisqKsxrId5om3RfOxyOhHp9ByRy+xO57Yr20/5EbX8it7072h8Px08lJSURl9f5+3v81FXnnwL6pYu4e9kk2vKT/a+rhvRccWe3/B2iwZue2+V/dwCIZ3y3dP93S0ePnwj6RaAnLFW/fv2ivSkAACCGjh+ysrIkFrf7kksukccff1zy8vI6vN4999xjSoG2NmDAgE7eQgAAEK9i9fjpQLV3/JQo55/eEZE50oNcemO0twAA8C0l4ndL9T6Onwj6RdCnTx/ZsmWLZGRkiMVi6ZKIrB7Q6XNkZmZKIqHttJ22J4ZEbbei7YnXdr3CSg+49PihJ9DAnc1mk507d4bN1+mioqI2y69bt042btwoZ5xxRnBeIFMvKSlJVq9eLUOGDGmz3k033STXXHNN2Dp79uyR3NzcLjl+irZEfX0HJHL7E7ntivbT/kRtfyK3vTvaH+vHT0rn78/yiXj81Fqiv696IvZJz8R+6ZnYLz1TIu0XXwePnwj6RaClK/r27dvlz6Mvwnh/IbaHttP2RJOobU/Udivanlht70lXqGsZrnHjxsmCBQtk2rRpwRNKOn3llVe2WX7EiBGyfPnysHm33HKLOZD83e9+1+6V58nJyWYIlZ2dLfEuEV/foRK5/YncdkX7aX+itj+R297V7Y/l4yc1adIkc//VV18dnPfOO++Y+e1J1OOn1hL9fdUTsU96JvZLz8R+6ZkSZb9kdeD4iaAfAABAnNEryGfOnCnjx4+XCRMmyNy5c6W2tlZmzZpl7p8xY4YUFxebElPaB+Ohhx4a8eRT6/kAAADxan+On9RVV10lxx13nDzwwANy+umny0svvSSfffaZ/OlPf4pySwAAQCIj6AcAABBnpk+fLqWlpTJnzhwpKSmRMWPGyPz586WwsNDcv3nzZlPZAAAAAAd2/HTUUUfJCy+8YCok3HzzzTJs2DB5/fXXuWgKAABEFUG/KNBSDrfddlubkg6JgLbT9kSTqG1P1HYr2p6Ybe+JtBRVe+WoFi5cuNd1n3rqqS7aqtiV6K/vRG5/Irdd0X7an6jtT+S2J3L79/f46fvf/74Z0DGJ+rrqydgnPRP7pWdiv/RM7Je2LD7t/Q8AAAAAAAAAAABAzKKuEwAAAAAAAAAAABDjCPoBAAAAAAAAAAAAMY6gHwAAAAAAAAAAABDjCPp1kYcfflgGDhwoTqdTJk6cKJ988slel3/llVdkxIgRZvlRo0bJW2+9JbHmnnvukSOOOEIyMjKkoKBApk2bJqtXr97rOk899ZRYLJawQf8Gseb2229v0w7dn/G+z5W+zlu3XYcrrrgi7vb5//73PznjjDOkT58+Zrtff/31sPu1i9Q5c+ZI7969JSUlRU466SRZs2ZNp39e9LS2u91uueGGG8zrOC0tzSwzY8YM2b59e6e/b3raPr/00kvbtOGUU06J+32uIr3vdbj//vtjep8DrW3btk0uvvhiyc3NNZ/t+ln32WefSSLweDxy6623yqBBg0zbhwwZInfddZf5votHXfU9Hyu64rs+nvZ/qJ/+9Kdmmblz50qitH3lypVy5plnSlZWlnkN6O++zZs3SyK0v6amRq688krp27evee8fcsgh8thjj0k86Mhv+IaGBvPbTr8H09PT5dxzz5WdO3dGbZvR/QK/eX7961+Hzdf3is4PPW747W9/a74r9HdOTk6OnHrqqfLBBx+0e07AarWa79Xp06e3+Uz5zne+E/F51emnn27u098X2P99qd9jren7XO/TZQLL6mcCvp3S0lK57LLLpH///pKcnCxFRUUydepU+eUvf9nub+qODoHX/xdffCHf//73pbCw0Lz3hg0bJrNnz5Zvvvkm2s2PSSUlJfKzn/1MBg8ebPZZv379zHHCggUL2pwH1eMCnT7vvPPk3Xffjfamx432Pn8WLlxo/u7PPvusOR5du3Zt2P3620S/e/7whz+02Ve6/NixY835+ERA0K8LvPzyy3LNNdfIbbfdJp9//rmMHj3afKDv2rUr4vIffvihXHDBBfLDH/7QfFDri1qHr776SmLJe++9Zw4SPvroI3nnnXfMyYEpU6ZIbW3tXtfLzMyUHTt2BIdNmzZJLBo5cmRYOxYtWtTusvGyz9Wnn34a1m7d90oPOOJtn+trWd/PGrCJ5L777pPf//735iTAxx9/bL5Q9L2vP5Q76/OiJ7a9rq7ObLueGNbb1157zZws0BND+7I/75ueuM+VBvlC2/Diiy/u9THjYZ+r0DbrMG/ePHMgpSeCYnmfA6HKy8vl6KOPFrvdLv/617/k66+/lgceeMD8kEgE9957rzz66KPmR5Oe8Ndp/a576KGHJB51xfd8LOmq7/pY0ZHvfPW3v/3N/N7RAFGitH3dunUyefJkc6GOnmxZtmyZeS3EyoV737b9etw2f/58ee6558xn4dVXX22CgG+88YbEuo78hv/5z38u//jHP8xJMl1eT6idc845Ud1udD99v+txgB4bRaIXxpx//vly5513ylVXXWXeK/p5oSfLNXjXOpgeOCegF1e9+uqr5jsl0jkEXV+DhKF0HT35rsFC7D/9m7700ktSX18fnKfHMi+88IIJTKFz6e9jPe/39NNPmyCcfnfoe0KD46G/izVo1Prcgp4rC4zrhUatz6Vde+218s9//lOOPPJIaWxslOeff9689/T7Si/S0e9q7J+NGzfKuHHjTABPL2hevny5OQY4/vjjw5Ib9LNO94F+dj3zzDOSnZ1tLgjUYC66ngZh9XeYBge9Xm9wvga7df9dEWFf6ftQL3TSi0z0vHzc86HTTZgwwXfFFVcEpz0ej69Pnz6+e+65J+Ly5513nu/0008Pmzdx4kTfT37yE18s27Vrl14G7nvvvffaXebJJ5/0ZWVl+WLdbbfd5hs9enSHl4/Xfa6uuuoq35AhQ3xerzeu97m+tv/2t78Fp7W9RUVFvvvvvz84r6KiwpecnOx78cUXO+3zoie2PZJPPvnELLdp06ZOe9/0xHbPnDnTd9ZZZ+3X48TrPte/wwknnLDXZWJtnwM33HCDb/Lkyb5EpccqP/jBD8LmnXPOOb6LLrrIF+8663s+VnXWd328tX/r1q2+4uJi31dffeUbMGCA77e//a0vEdo+ffp038UXX+xLBJHaP3LkSN+dd94ZNm/s2LG+X/ziF7540/o3vH7O2e123yuvvBJcZuXKlWaZxYsXR3FL0Z30N893v/td34gRI3zXXXddcL6+VwKnFV966SUz/sYbb7RZX48dcnNzfTU1Ne2eE/j9739v1q+srAzOO+6443yXXXaZWXfRokXB+b/85S99Z5xxhvldob8v0HGB36+HHnqo77nnngvOf/75532HHXaYuU+XCV0WB668vNy8rhcuXLjPZff19470vqmtrfXl5eX5pk2b1u7zY/+ceuqp5lgv8HkV6e/Z3jHgnDlzfFar1bdq1apu2dZ41t774b///a95T+m+0GOW/Pz84O+zwHtk8+bNweVb7yu32+1LTU313Xjjjb54R6ZfJ3O5XLJkyRIT3Q/QcgU6vXjx4ojr6PzQ5ZVGq9tbPlZUVlaa2169eu11OS2XMmDAAHO10VlnnSUrVqyQWKTlnfSKX03/vuiii/Za7iZe97m+/vWKoh/84AdhZT7idZ+H2rBhgykBELpf9coqLd3Y3n49kM+LWHr/62tAr3bqrPdNT6VXsGo5pIMOOsiU7di9e3e7y8brPtcST2+++abJXt6XeNjnSBx6Je748ePNlef6Pj/88MPl8ccfl0Rx1FFHmSvpA6WBvvzyS5Odq6W6Es2BfM/Hu45+18cLvYr4kksukeuuu85krScKbbd+xw8fPtz8XtHPQn3d7638aTx+Fur3gWYXaVzwv//9r/lc1Iy4eNP6N7wet2r2X+hnn2Z8ajZQon72JSqbzSa/+tWvTLb/1q1b29yvWWL6OaHZF639v//3/8xvpEBVoNa04olmUetz6BDK4XCY3wxPPvlkcJ5m/uk5Bxw4/fuF/k21asusWbOiuk3xSEsi66DfmZqJ19nefvttKSsrk+uvvz7i/YlyjNZZ9uzZY7L6NEtMK3rs799Ts5z1OOHvf/97F24lAvLz8+VPf/qTyWjV7xetTPC73/3OnGtuT1JSkqnio+fm4h1Bv06mH7Zax1zrKIfSaT1REInO35/lY+XHoZY90ZJYhx56aLvL6UlyPbjQD0QNFul6+qMq0kFkT6Y/fPXAU78ctAyWnhg65phjpLq6OmH2udIDmYqKimAN+Hje560F9t3+7NcD+byIBVoaRPv90RK2Wn6is943PZGW39BSDnpSXMvdaMkjPRmu+zWR9rmWKtG+YPZV6ike9jkSy/r1681rVfvF0B/VGtj/v//7P/OaTwQ33nijKdWlJ3j1x5EGPfX4Tk++JZoD+Z6PZx39ro8n+j2vJwr0MyCR6Ml4vWBP+9TS455///vfcvbZZ5vvfD3uSQQa5NB+/LRPPw1A6N9BS4Eee+yxEk8i/YbXzzdtc+sTnYn62Zfo9L0/ZswY001BaxoIP/jggyOuF5gf2r+YBpg1GKIn1vX1pMH09k60a4DqL3/5iyk7q31w6rrf/e53O7VtiUb7q9YLubR8pA7a76LOQ+fS4wb9/au/HfRzVD9fb775ZlMmuzME+pbWY3V8e9o/nAbtDvTvqRfM6MVRWiIU356Wrg0EzgND64tPtausQGnc4447TmbOnNnu47lcLtOXsX6HnHDCCRLvkqK9AYhPerCm/dPtq6+mSZMmmSFAgz96QPjHP/5R7rrrLokVoR86hx12mDmxrZlsemDakcyXePHEE0+Yv8Xe+jiJl32OyPRKYP3C1QMlPVEe7+8bPRkeoDX5tR1Dhgwx2X8nnniiJAoN5GsQYF99+8TDPkdi0ROgmumnV7YrDXrp8Y326ba3HxTxQt+b2jeIXr2vmU1Lly41J4T1ez4R2o9v/10fLzTbSa8c1v4M91bNIh4F+knR6hx6BbXSk/7aF4p+FuoJlkQI+mmfd5rtp8ctGnTQ37v6Wdi6eksi/IZHYtMLIPRkqfYl1pq/Qm7H6AWD+pmq3ynab7Ieb7TXF5b2uakXYP31r381wUHNutZgCr5dhszpp59uAlK633Q8Ly8v2psVt3366d/3/fffN98l+nrXfqL//Oc/7/WC+Y7Yn/ccuufvqY+RaMeKXUX7UWz9W0P7VW99gYJm+unF+LfcckvEx7nhhhvMfXrRogYO9UI2fU/GO74lO5l+SWo5Ai11Fkqni4qKIq6j8/dn+Z5OOzXXaLz+GNKrIfdH4CpyvboilukVPFraor12xNs+V3p12H/+8x957bXXEnKfB/ad7sfQDsV1Wk+MdNbnRSycBNTXgnZ6vL9X/u/rfRMLtGSl7ldtQ6SgX7ztc6U/XrTz6pdffnm/142HfY74pp/nmt0RSi9UefXVVyURaBnDQLZf4OIG/YzXKyQTLeh3IN/z8ejbftfHKv2u04w3LWkYoJn7WrJu7ty5cX1Ftx676Mn1SJ+FiRAcqq+vN1kZWnowcIJIL1zSiyB+85vfxE3Qr73f8PrZp1fGazWX0Gy/WD52xbejGa5a6vemm24KC1joMf3KlSsjrhOYr8uEdnEwdOjQ4OfJunXrTEWFZ599NuJjaLafZth+/fXX8sknn3RyqxKT/k31va/0b4uuoxfHnnzyyWbQAMWPfvQjkzH7bYN+gffUqlWrwi6ux4HRiws0YKd/zwOhZYxLS0tl0KBBnb5tiUgzvwPfEwGRqsQFLgJp72KQ6667zrzXNOCnmeWJEpSlvGcn09IX48aNM6XeQq+O1On2PoB1fujySmvRxtoHtl7NoAcM+oNITwIcyIec/nhevnx52MmUWKQlcPSgtb12xMs+D6X14DWNfX+vloiXfa6vd/3hG7pfq6qqzFUo7e3XA/m86OknAbW8hAZ/c3NzO/19Ewv0AEQP9NprQzzt89AMX22TXoGbiPsc8U1L8GhQO5SWptJMj0RQV1dnTsqF0gsXApk/ieRAvufjTWd818cqzSrRUlwa6AkMmuWlJxG09G8802OXI444ImE/C/V1r0O8fhbu6ze8HuPpRZqhn336WtA+mRPlsw9taZbEP/7xj7B+HfUCIf1+0PmtPfDAA+Y7QwMe7dGLjPQiQs3+i+TCCy805w209GzrixBwYLQcngb19TNOA7noPvoa1nK135b2LasX52jmYCR6wQb2rzynvhc0CB5p/+zr76lVIfR4QUtOoufIy8szwUP9LZcoAT9Fpl8XuOaaa8zVz1oOasKECebqT/2wCHSKO2PGDCkuLjZXSQc6+tSyKHogpAGTl156ST777DPTGWWslQPR8k/aV5uWagjU+M/KypKUlJSIbb/zzjvlyCOPNG8+/fC8//77zZXDetVLLNHSFtphtf7w3b59u7liR38Iaj8n8bzPA/QHrwb99HXf+sqKeNrnGqAIzUjS/sj0pI8eGOiV31ry7O677zZXB+kPZr2CS08IhX7ha/aX9oUQuKJuX58XsdB2Ddh873vfMz/Q9AphDeQG3v96v54sitT2fb1venq7dbjjjjtMuQ49eNDglXagra/t0B9N8bjPA5kOesL7lVdeMZ9lkcTiPgdCaSk7LUOt5T012KFXlut3dax+X+8vfb9qqS19z2t5zy+++EIefPBBc2V4POqM7/lY1hnf9fG8/1sHOTUQot//2l91vLddg5vTp083GT5aakn75tUT+1rOPB7sq/36u03/BvqbVo9htC9DLSOln4exbl+/4fVWS7Dr8av+PTS792c/+5kJ+OlvOiQmzfzX0v6///3vw4J++rtAf+fob3z9HaC/FfTkuZbG1fsi9dcX0K9fP/O7Yc6cOeZ7prWcnBzZsWOH+exF59DfYYEsTB1H59MLgr///e+bY2fNEtfPWT33p0E6LZv9bel7SsuE6nOceeaZpt9hPR9RVlZmyvTrBRp6vhEdp59ZeuGnnqvR85e635qamkyihpaaDLxnqqurzXemBs31uOG5554z+0LPfbbOTgOiwocu8dBDD/n69+/vczgcvgkTJvg++uij4H3HHXecb+bMmWHL/+Uvf/ENHz7cLD9y5Ejfm2++6Ys1+nKKNDz55JPttv3qq68O/p0KCwt9p512mu/zzz/3xZrp06f7evfubdpRXFxspteuXRv3+zzg7bffNvt69erVbe6Lp33+3//+N+JrPNA+r9fru/XWW027kpOTfSeeeGKbv8mAAQN8t912W4c/L2Kh7Rs2bGj3/a/rtdf2fb1venq76+rqfFOmTPHl5+f77Ha7ad/s2bN9JSUlcb/PA/74xz/6UlJSfBUVFREfIxb3OdDaP/7xD9+hhx5qPtdHjBjh+9Of/uRLFFVVVb6rrrrKfF45nU7f4MGDfb/4xS98jY2NvnjUGd/zsawzvutjWUe+91p/x/32t7/1JUrbn3jiCd/QoUPNZ8Ho0aN9r7/+ui9e7Kv9O3bs8F166aW+Pn36mPYfdNBBvgceeMB8JsS6jvyGr6+v911++eW+nJwcX2pqqu/ss882fxMkDn0vnHXWWWHz9HtBj+lDTyu63W7f/fffb85v6H2ZmZm+qVOn+hYtWhS2rr6+srKy2jzP4sWLzeN9/PHHwXMJehzSHv0sav07C/u/L0PpfYHPvn0ti31raGjw3Xjjjb6xY8ea17x+hup3yC233GLOJ4Ta19+7vfeN+vTTT33nnHOOOTehx6j6ff3jH//Yt2bNmk5vUyLYvn2774orrjDHeoFzF2eeeWbwmFfnB74v9X79rXTeeef53n333Whvetxo7/0QOGYrLy8Pzgv8Tvniiy/i+nh9f1n0v+iEGwEAAAAAAAAAAAB0Bvr0AwAAAAAAAAAAAGIcQT8AAAAAAAAAAAAgxhH0AwAAAAAAAAAAAGIcQT8AAAAAAAAAAAAgxhH0AwAAAAAAAAAAAGIcQT8AAAAAAAAAAAAgxhH0AwAAAAAAAAAAAGIcQT8AAAAAAAAAAAAgxhH0A4AuZrFY5PXXX4/2ZgAAAMQMjp8AAAAAYP8R9AMQ1y699FJz0qj1cMopp0R70wAAAHokjp8AAAAAIDYlRXsDAKCr6QmqJ598MmxecnJy1LYHAACgp+P4CQAAAABiD5l+AOKenqAqKioKG3Jycsx9etX6o48+KqeeeqqkpKTI4MGD5a9//WvY+suXL5cTTjjB3J+bmys//vGPpaamJmyZefPmyciRI81z9e7dW6688sqw+8vKyuTss8+W1NRUGTZsmLzxxhvd0HIAAIADw/ETAAAAAMQegn4AEt6tt94q5557rnz55Zdy0UUXyfnnny8rV64099XW1srUqVPNSa5PP/1UXnnlFfnPf/4TdlJKT3pdccUV5mSWnuDSE1JDhw4Ne4477rhDzjvvPFm2bJmcdtpp5nn27NnT7W0FAADoDBw/AQAAAEDPY/H5fL5obwQAdGWfNM8995w4nc6w+TfffLMZ9Er1n/70p+bEU8CRRx4pY8eOlUceeUQef/xxueGGG2TLli2SlpZm7n/rrbfkjDPOkO3bt0thYaEUFxfLrFmz5O677464Dfoct9xyi9x1113BE2Hp6enyr3/9i75xAABAj8PxEwAAAADEJvr0AxD3jj/++LCTUqpXr17B8UmTJoXdp9NLly4143rF+ujRo4MnrNTRRx8tXq9XVq9ebU5I6cmrE088ca/bcNhhhwXH9bEyMzNl165d37ptAAAAXYHjJwAAAACIPQT9AMQ9PUnUulxUZ9F+ajrCbreHTevJLj3xBQAA0BNx/AQAAAAAsYc+/QAkvI8++qjN9MEHH2zG9Vb7qtGSUgEffPCBWK1WOeiggyQjI0MGDhwoCxYs6PbtBgAAiBaOnwAAAACg5yHTD0Dca2xslJKSkrB5SUlJkpeXZ8ZfeeUVGT9+vEyePFmef/55+eSTT+SJJ54w91100UVy2223ycyZM+X222+X0tJS+dnPfiaXXHKJ6Y9G6Xzt16agoEBOPfVUqa6uNie2dDkAAIBYxPETAAAAAMQegn4A4t78+fOld+/eYfP0KvNVq1aZ8TvuuENeeuklufzyy81yL774ohxyyCHmvtTUVHn77bflqquukiOOOMJMn3vuufLggw8GH0tPaDU0NMhvf/tbufbaa83JsO9973vd3EoAAIDOw/ETAAAAAMQei8/n80V7IwAgWrRvmL/97W8ybdq0aG8KAABATOD4CQAAAAB6Jvr0AwAAAAAAAAAAAGIcQT8AAAAAAAAAAAAgxlHeEwAAAAAAAAAAAIhxZPoBAAAAAAAAAAAAMY6gHwAAAAAAAAAAABDjCPoBAAAAAAAAAAAAMY6gHwAAAAAAAAAAABDjCPoBAAAAAAAAAAAAMY6gHwAAAAAAAAAAABDjCPoBAAAAAAAAAAAAMY6gHwAAAAAAAAAAABDjCPoBAAAAAAAAAAAAEtv+P5vZXQcmB3jiAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "====================================================\n", + " ABLATION STUDY SUMMARY\n", + "====================================================\n", + " Model ROC-AUC macro F1 macro\n", + "----------------------------------------------------\n", + " ResNet1d 0.5058 0.0000\n", + " BiLSTM1d 0.5029 0.0000\n", + "====================================================\n", + "\n", + " Best model by ROC-AUC: ResNet1d\n", + " (Run 5 seeds → mean±std → Welch's t-test for the paper)\n" + ] + } + ], + "source": [ + "# ── STEP 12b: Ablation Comparison — SparcNet vs BiLSTMECG ────────────────────\n", + "#\n", + "# Both models were trained and evaluated using identical PyHealth:\n", + "# • PTBXLDataset (BaseSignalDataset subclass)\n", + "# • SampleSignalDataset (ptbxl_superdiagnostic_fn task)\n", + "# • split_by_patient (same 80/10/10 patient split, seed=42)\n", + "# • Trainer (same epochs / lr / patience / monitor)\n", + "# • multilabel_metrics_fn (same evaluation protocol)\n", + "\n", + "models = [\"SparcNet\", \"BiLSTMECG\"]\n", + "auc_vals = [sparcnet_scores[\"roc_auc_macro\"], bilstm_scores[\"roc_auc_macro\"]]\n", + "f1_vals = [sparcnet_scores[\"f1_macro\"], bilstm_scores[\"f1_macro\"]]\n", + "colors = [\"#2196F3\", \"#FF5722\"]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "fig.suptitle(\"Ablation Study: SparcNet vs BiLSTMECG\\n\"\n", + " \"PyHealth pipeline — PTB-XL superdiagnostic (5 classes)\",\n", + " fontsize=12, fontweight=\"bold\")\n", + "\n", + "# ROC-AUC bars\n", + "axes[0].bar(models, auc_vals, color=colors, edgecolor=\"white\", width=0.5)\n", + "axes[0].axhline(0.5, color=\"gray\", linestyle=\"--\", linewidth=1, label=\"Random (0.5)\")\n", + "for i, (m, v) in enumerate(zip(models, auc_vals)):\n", + " axes[0].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=11, fontweight=\"bold\")\n", + "axes[0].set_ylim(0, 1.0)\n", + "axes[0].set_ylabel(\"ROC-AUC (macro)\", fontsize=11)\n", + "axes[0].set_title(\"Test ROC-AUC\", fontweight=\"bold\")\n", + "axes[0].legend(fontsize=9)\n", + "\n", + "# F1 bars\n", + "axes[1].bar(models, f1_vals, color=colors, edgecolor=\"white\", width=0.5)\n", + "for i, (m, v) in enumerate(zip(models, f1_vals)):\n", + " axes[1].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=11, fontweight=\"bold\")\n", + "axes[1].set_ylim(0, 1.0)\n", + "axes[1].set_ylabel(\"F1 Score (macro)\", fontsize=11)\n", + "axes[1].set_title(\"Test F1 Score\", fontweight=\"bold\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# ── Summary table ─────────────────────────────────────────────────────────────\n", + "print(\"\\n\" + \"=\" * 62)\n", + "print(\" ABLATION SUMMARY (PyHealth Trainer + multilabel_metrics_fn)\")\n", + "print(\"=\" * 62)\n", + "print(f\" {'Model':<18} {'ROC-AUC macro':>14} {'F1 macro':>10} {'Loss':>8}\")\n", + "print(\" \" + \"─\" * 56)\n", + "for m, auc, f1, scores in [\n", + " (\"SparcNet\", sparcnet_scores[\"roc_auc_macro\"], sparcnet_scores[\"f1_macro\"], sparcnet_scores),\n", + " (\"BiLSTMECG\", bilstm_scores[\"roc_auc_macro\"], bilstm_scores[\"f1_macro\"], bilstm_scores),\n", + "]:\n", + " print(f\" {m:<18} {auc:>14.4f} {f1:>10.4f} {scores['loss']:>8.4f}\")\n", + "print(\"=\" * 62)\n", + "\n", + "best = \"SparcNet\" if auc_vals[0] >= auc_vals[1] else \"BiLSTMECG\"\n", + "print(f\"\\n Best model by ROC-AUC: {best}\")\n", + "print(\" Note: For publication, run 5 independent seeds and report mean±std.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "23aa34ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=======================================================\n", + " REPRODUCIBILITY CHECKLIST\n", + "=======================================================\n", + " Python : 3.9.6\n", + " PyTorch : 2.8.0\n", + " NumPy : 1.26.4\n", + " scikit-learn : 1.6.1\n", + " pandas : 2.3.3\n", + "-------------------------------------------------------\n", + " Random seed : 42 (passed to split_by_patient + model init)\n", + " Window length : 1250 samples (2.5 s × 500 Hz)\n", + " Overlap : 50% (stride = 625 samples)\n", + " Num classes : 5 (NORM, CD, HYP, MI, STTC)\n", + " Loss : BCEWithLogitsLoss (multi-label)\n", + " Optimizer : Adam (lr=1e-3)\n", + " Batch size : 32\n", + " Early stop : patience=3, monitor=val_roc_auc_macro\n", + "=======================================================\n", + "\n", + "✅ This notebook is self-contained and runnable on any machine.\n", + " Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\n", + " Set PTBXL_ROOT in cell 3 and re-run all cells.\n" + ] + } + ], + "source": [ + "# ── STEP 12c: Reproducibility check — print all environment versions ──────────\n", + "\n", + "import sys, torch, numpy, sklearn, pandas\n", + "\n", + "print(\"=\" * 55)\n", + "print(\" REPRODUCIBILITY CHECKLIST\")\n", + "print(\"=\" * 55)\n", + "print(f\" Python : {sys.version.split()[0]}\")\n", + "print(f\" PyTorch : {torch.__version__}\")\n", + "print(f\" NumPy : {numpy.__version__}\")\n", + "print(f\" scikit-learn : {sklearn.__version__}\")\n", + "print(f\" pandas : {pandas.__version__}\")\n", + "print(\"-\" * 55)\n", + "print(f\" Random seed : 42 (passed to split_by_patient + model init)\")\n", + "print(f\" Window length : 1250 samples (2.5 s × 500 Hz)\")\n", + "print(f\" Overlap : 50% (stride = 625 samples)\")\n", + "print(f\" Num classes : 5 (NORM, CD, HYP, MI, STTC)\")\n", + "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", + "print(f\" Optimizer : Adam (lr=1e-3)\")\n", + "print(f\" Batch size : 32\")\n", + "print(f\" Early stop : patience=3, monitor=val_roc_auc_macro\")\n", + "print(\"=\" * 55)\n", + "print(\"\\n✅ This notebook is self-contained and runnable on any machine.\")\n", + "print(\" Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\")\n", + "print(\" Set PTBXL_ROOT in cell 3 and re-run all cells.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3dfb390b", + "metadata": {}, + "source": [ + "---\n", + "## Section 13 — Graph Convolutional Network (GCN) Layer\n", + "\n", + "A GCN layer generalises convolution to irregular graph-structured data. \n", + "For ECG this is useful because the 12 leads can be treated as a **graph of electrodes**,\n", + "where edges encode physical proximity or learned correlations between leads.\n", + "\n", + "### The formula\n", + "\n", + "$$X' = \\hat{D}^{-1/2}\\,\\hat{A}\\,\\hat{D}^{-1/2}\\,X\\,\\Theta$$\n", + "\n", + "| Symbol | Shape | Meaning |\n", + "|---|---|---|\n", + "| $A$ | $N \\times N$ | Adjacency matrix (given as `edge_index`) |\n", + "| $\\hat{A} = A + I$ | $N \\times N$ | Adjacency **with self-loop** — every node aggregates its own features too |\n", + "| $\\hat{D}_{ii} = \\sum_j \\hat{A}_{ij}$ | $N \\times N$ diagonal | Degree matrix of $\\hat{A}$ |\n", + "| $\\hat{D}^{-1/2}$ | $N \\times N$ diagonal | Symmetric normalisation — prevents scale explosion in dense graphs |\n", + "| $X$ | $N \\times D_{in}$ | Input node feature matrix |\n", + "| $\\Theta$ | $D_{in} \\times D_{out}$ | Learnable weight matrix |\n", + "| $X'$ | $N \\times D_{out}$ | Output node features |\n", + "\n", + "### Why symmetric normalisation?\n", + "\n", + "Without normalisation, nodes with high degree would dominate aggregation. \n", + "$\\hat{D}^{-1/2}\\hat{A}\\hat{D}^{-1/2}$ divides each edge weight $\\hat{A}_{ij}$ by $\\sqrt{d_i \\cdot d_j}$,\n", + "so high-degree nodes contribute proportionally less — analogous to mean aggregation.\n", + "\n", + "### Step-by-step implementation\n", + "\n", + "```\n", + "edge_index (2, E) — pairs of connected node indices\n", + " │\n", + " ▼\n", + "Step 1: Build A ∈ R^(N×N) [scatter 1s at (src, dst) positions]\n", + " │\n", + " ▼\n", + "Step 2:  = A + I [add identity → self-loop]\n", + " │\n", + " ▼\n", + "Step 3: d̂ = Â.sum(dim=1) [row sums = node degrees]\n", + " │ D̂ = diag(d̂)\n", + " ▼\n", + "Step 4: D̂^(-1/2) = diag(d̂^(-0.5))\n", + " │\n", + " ▼\n", + "Step 5: norm_adj = D̂^(-1/2)  D̂^(-1/2) [2 matrix multiplications]\n", + " │\n", + " ▼\n", + "Step 6: X' = norm_adj @ X @ Θ [2 more matrix multiplications]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8788cd11", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "\n", + "class GCNConv(torch.nn.Module):\n", + " \"\"\"\n", + " Graph Convolutional Network layer (Kipf & Welling, ICLR 2017).\n", + "\n", + " Computes:\n", + " X' = D̂^(-1/2)  D̂^(-1/2) X Θ\n", + "\n", + " where:\n", + "  = A + I (adjacency with self-loop)\n", + " D̂ = diag( @ 1) (diagonal degree matrix of Â)\n", + " Θ ∈ R^(in_channels × out_channels) (learnable weight)\n", + "\n", + " Parameters\n", + " ----------\n", + " in_channels : int D_in — input feature dimension per node\n", + " out_channels : int D_out — output feature dimension per node\n", + " \"\"\"\n", + "\n", + " def __init__(self, in_channels: int, out_channels: int):\n", + " super(GCNConv, self).__init__()\n", + "\n", + " # Learnable weight matrix Θ ∈ R^(D_in × D_out)\n", + " self.theta = nn.Parameter(torch.FloatTensor(in_channels, out_channels))\n", + "\n", + " # Initialise Θ with uniform distribution scaled by 1/√D_out\n", + " # (same as PyTorch's default Linear initialisation)\n", + " stdv = 1.0 / math.sqrt(out_channels)\n", + " self.theta.data.uniform_(-stdv, stdv)\n", + "\n", + " def forward(self, x: torch.Tensor, edge_index: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"\n", + " Parameters\n", + " ----------\n", + " x : torch.Tensor shape (N, D_in)\n", + " Node feature matrix.\n", + " edge_index : torch.Tensor shape (2, E)\n", + " Graph edges in COO format:\n", + " edge_index[0] — source node indices\n", + " edge_index[1] — destination node indices\n", + "\n", + " Returns\n", + " -------\n", + " x_prime : torch.Tensor shape (N, D_out)\n", + " \"\"\"\n", + " N = x.size(0) # number of nodes\n", + "\n", + " # ── Step 1: Build sparse adjacency matrix A from edge_index ──────────\n", + " # A[src, dst] = 1 for every edge (src → dst) in edge_index\n", + " A = torch.zeros(N, N, dtype=x.dtype, device=x.device)\n", + " A[edge_index[0], edge_index[1]] = 1.0\n", + "\n", + " # ── Step 2: Add self-loop →  = A + I ──────────────────────────────\n", + " # Ensures every node aggregates its own features in addition to neighbours\n", + " A_hat = A + torch.eye(N, dtype=x.dtype, device=x.device)\n", + "\n", + " # ── Step 3: Diagonal degree matrix D̂_ii = Σ_j Â_ij ─────────────────\n", + " # Row-sum of  gives the degree of each node (including self-loop)\n", + " d_hat = A_hat.sum(dim=1) # (N,) — degree vector\n", + " D_hat_inv_sqrt = torch.diag(d_hat.pow(-0.5)) # (N, N) diagonal matrix\n", + "\n", + " # ── Step 4: Symmetric normalisation D̂^(-1/2)  D̂^(-1/2) ───────────\n", + " # Each edge weight A_hat[i,j] is divided by sqrt(d_i) * sqrt(d_j)\n", + " norm_adj = torch.mm(torch.mm(D_hat_inv_sqrt, A_hat), D_hat_inv_sqrt) # (N, N)\n", + "\n", + " # ── Step 5: Graph convolution X' = norm_adj X Θ ───────────────────\n", + " # First multiply normalised adjacency × features: (N,N) @ (N,D_in) → (N,D_in)\n", + " # Then project through Θ: (N,D_in) @ (D_in,D_out) → (N,D_out)\n", + " x_prime = torch.mm(torch.mm(norm_adj, x), self.theta) # (N, D_out)\n", + "\n", + " return x_prime" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "88926470", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input X shape: torch.Size([3, 4])\n", + "Output X' shape: torch.Size([3, 2])\n", + "\n", + "Output X':\n", + " tensor([[-0.2402, -0.0228],\n", + " [-0.3073, 0.0588],\n", + " [-0.3738, -0.1176]], grad_fn=)\n", + "\n", + "Adjacency A:\n", + " tensor([[0, 1, 0],\n", + " [1, 0, 1],\n", + " [0, 1, 0]], dtype=torch.int32)\n", + "\n", + " = A + I:\n", + " tensor([[1, 1, 0],\n", + " [1, 1, 1],\n", + " [0, 1, 1]], dtype=torch.int32)\n", + "\n", + "Degree vector d̂ = Â.sum(dim=1): tensor([2., 3., 2.])\n", + " (node 0 has 2 neighbours + self → d̂[0]=2,\n", + " node 1 has 3 neighbours + self → d̂[1]=3, etc.)\n", + "\n", + "D̂^(-1/2) diagonal: [0.7071067690849304, 0.5773502588272095, 0.7071067690849304]\n", + "\n", + "Normalised adjacency D̂^(-1/2)  D̂^(-1/2):\n", + " tensor([[0.5000, 0.4082, 0.0000],\n", + " [0.4082, 0.3333, 0.4082],\n", + " [0.0000, 0.4082, 0.5000]])\n", + "\n", + "✅ GCNConv forward pass verified.\n", + " Output shape (N, D_out) = (3, 2)\n" + ] + } + ], + "source": [ + "# ── Verify the implementation with a concrete worked example ─────────────────\n", + "#\n", + "# Graph: 3 nodes (0, 1, 2), edges: 0→1, 1→0, 1→2, 2→1\n", + "# 0\n", + "# / \\\n", + "# 1 — 2\n", + "\n", + "torch.manual_seed(0)\n", + "\n", + "N = 3 # nodes\n", + "D_in = 4 # input feature dim\n", + "D_out = 2 # output feature dim\n", + "\n", + "# Node features X ∈ R^(3 × 4)\n", + "x_test = torch.tensor([[1., 0., 0., 0.],\n", + " [0., 1., 0., 0.],\n", + " [0., 0., 1., 0.]], dtype=torch.float32)\n", + "\n", + "# Edges (undirected → both directions): 0↔1, 1↔2\n", + "edge_index_test = torch.tensor([[0, 1, 1, 2],\n", + " [1, 0, 2, 1]], dtype=torch.long)\n", + "\n", + "# Instantiate and run\n", + "gcn = GCNConv(in_channels=D_in, out_channels=D_out)\n", + "x_out = gcn(x_test, edge_index_test)\n", + "\n", + "print(\"Input X shape:\", x_test.shape)\n", + "print(\"Output X' shape:\", x_out.shape)\n", + "print(\"\\nOutput X':\\n\", x_out)\n", + "\n", + "# ── Manual verification of  and D̂ to confirm correctness ──────────────────\n", + "A = torch.zeros(N, N)\n", + "A[edge_index_test[0], edge_index_test[1]] = 1.0\n", + "A_hat = A + torch.eye(N)\n", + "d_hat = A_hat.sum(dim=1)\n", + "\n", + "print(\"\\nAdjacency A:\\n\", A.int())\n", + "print(\"\\n = A + I:\\n\", A_hat.int())\n", + "print(\"\\nDegree vector d̂ = Â.sum(dim=1):\", d_hat)\n", + "print(\" (node 0 has 2 neighbours + self → d̂[0]=2,\")\n", + "print(\" node 1 has 3 neighbours + self → d̂[1]=3, etc.)\")\n", + "\n", + "print(\"\\nD̂^(-1/2) diagonal:\", d_hat.pow(-0.5).tolist())\n", + "\n", + "D_inv_sqrt = torch.diag(d_hat.pow(-0.5))\n", + "norm_adj = torch.mm(torch.mm(D_inv_sqrt, A_hat), D_inv_sqrt)\n", + "print(\"\\nNormalised adjacency D̂^(-1/2)  D̂^(-1/2):\\n\",\n", + " norm_adj.round(decimals=4))\n", + "\n", + "print(\"\\n✅ GCNConv forward pass verified.\")\n", + "print(\" Output shape (N, D_out) =\", tuple(x_out.shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "dda95b41", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAGMCAYAAAA1CuswAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAADbIElEQVR4nOzdB3wT5RsH8KebtrSUPcoespdskCUoCCogU1EQEUUQUVTAgUwBQRGRJRsH/hkKCCgIyJQpe+9d9ioUuvP//F6885ImbdKmTdP+vnzuQ3O5XC6Xy43nnvd5PUwmk0mIiIiIiIiIiIiIiCgBz4SjiIiIiIiIiIiIiIgIGEQnIiIiIiIiIiIiIrKBQXQiIiIiIiIiIiIiIhsYRCciIiIiIiIiIiIisoFBdCIiIiIiIiIiIiIiGxhEJyIiIiIiIiIiIiKygUF0IiIiIiIiIiIiIiIbGEQnIiIiIiIiIiIiIrKBQXQiIiIiIiIiIiIiIhsYRCciIiJyI6+++qp4eHioYf369an+fkOGDNHfb86cOan+fu4qLb6Xli1bqvk/9dRTqTL/jK5Ro0b6d3T27FnJDNJ6f0HuoUePHmqbqFixophMJlcvDhERkVtgEJ2IiMgBkZGRMnXqVBXEypMnj/j6+krevHmlatWq0rNnT1m1apXVC9KLFy9K//79pXLlyhIcHCyBgYFStmxZ6dq1q6xdu9ZqwBLD77//bjMgguVIStGiRRlASaaCBQvq6+7KlSv6eHy/OXLk0J9buXKl2eueeOIJ/bl//vlHMhvj9mttGD9+vKsX0S1t27ZN3x+8++67+nj8ro3rF/sZI9z40J7r1KlTipfjwIED8vLLL6v9V0hIiPj4+EiuXLmkSZMmMm/evBTPP7My7tsxYL1iP4MgZ7du3WTLli3i7saMGWP2Ge05hiXG8niJdYZtEtsmtnXLfXN6gX0glh2Ds1y+fFm++OILadasmRQrVkz8/f0lKChI6tSpI7Nnz04wvbYPOXjwoCxYsMBpy0FERJSRMYhORERkp+PHj6tg+VtvvSVr1qyR69evS0xMjFy7dk327t0r3333nTRv3lwiIiLMXvfLL79ImTJlZOzYsbJ//365d++ePHjwQI4ePSrff/+9tG3b1uZ7fv7552nwycgaBB80W7du1f/G93b79m2z4KYG28OuXbvU3whi4KYJkTN8+eWX6v8CBQpIixYtbE43ZcoUuXXrVqotx759++Snn35Sv4O7d+9KbGys3Lx5U/766y/p3LmzjBo1KtXeOzPBesV+BkFO3AipV6+eyh7GPsYRn3zyiWzatEkNOH65ysmTJ50aNLa1zrBNYtucP3++PPPMM/L888+rY256C6IPHTpUDc6yYcMGGThwoPz555+qlQVu+N+/f18dn1577TWzG29Qvnx5/RiHcxMiIiJKGoPoREREdrhz547K8MLFOeTMmVNdACPTDRetEydOVBfsnp7mh1YEX1988UU9sF6zZk2ZO3euCjj9+OOPKlvO29vb5vsi+xDTZmbx8fEqIJDWateubTWIbgyaWz7es2ePvqyPP/64yox0FsubM+5g4cKFegBPGzp06ODqxXI7CFIvW7ZM/d2mTRuVdWsLAmepme2P7GgEc3/44Qd1MxFZrMYbThMmTEi1984skHm+ceNGWbRokWqtpH3fM2bMkA8//NCheZUqVUq1jsGQLVs2cZU33nhDHj58KFmyZEmV+eP4i/3L0qVLpU+fPqqVGOB388orr0hmgHXbvXt3deN++fLlZjfb8Ls8ffq02fQvvPCC+h83fnGzhoiIiBLHIDoREZGdWaBaDV0E0Hfu3CmfffaZCqyjtEvv3r1VqQWUOvDz89Nf9/777+uZgwg0bd68Wbp06SKNGzdWWZs///yzuvBPzIgRI1L504lcunRJZashcxqlGbRSAk8++aQsWbJEn65+/fp603nLC3ItuIdBy8YGZN/jRkL+/PlVYCM0NFRef/11VeLGVtP8WbNmqc9dpEgRtSyWgWtXZqJry4JMPtixY4dewsc4nTEIHx0drZraV6lSRZXyCQgIUOt69OjR6jlbJXjOnz+vWiog+FWhQgWbyxoeHq6C9trrjNsMgkpNmzaV7Nmzq22zdOnS6gYQAlqWEBDF50IwBu+X0mb+1atX1wN42oBMakArDG1527VrZ7Z+vby89Hq92vrBukJNa5TZQZY/1mG5cuXk008/VS07bK3Dc+fOybPPPqvWO7anyZMn62VQatSooT7rY489luCzGrdHlEP4+uuvpUSJEmr6atWqyerVq+1eD/iNIyM2d+7c6jeAcgv9+vUza9GQmBUrVujr4emnn05y+m+//VZtE4mJiopS+yN7BmT3ahCYmzZtmirpghIu7du319cp2JP1ayxBgzImKIOlfReFCxe2GojH50FWNUp1aKUqatWqpVoAWZbQiouLU98f9jXYTrC/RQZ9Yuz9neA48NJLL6ntWCsfgu0QgW/s65wB6wD7Wvz2kYVuXB/4btEqKqU10bVx+K2cOHFCbZ9Zs2ZV+32UJrO8cYnSVPZsK9hnWULwf926dWqfogVunQ3l1bB/wefA+kIg2fjdGsum2cPe7Q3bg7YusX+ytR8yllbCPkljLEeTknWN4wm+R6xrrGP0n/Drr7+qcnOAZbYsL2bsW2Hx4sUOrR8iIqJMyURERERJKl68OK6a1TBq1Ci7XnP+/Hn9NRjWr1+f5GsGDx6sT1+9enX97y1btqjnu3btqo+bMmVKkvMrUqSIPv26detsTrd161azZbUc5s6dq6abPXu2Pm748OH66x8+fGgKDAxU4x977DF9/O+//27y8/OzOs98+fKZTp8+bfWzG9d3UsueWiIjI02+vr7q/bNkyWKKjo5W4ytWrKjGTZ061eTl5aX+Pnz4sHquU6dO+jIvXLhQn0+DBg1srls8FxUVZfU7M64HjLfcBrBeMP/GjRvr4z755BN9XoMGDbL5vvXr1zd73wULFpg8PDwSTFepUiX9b3z/STG+9syZM4lO++yzz+rTLl++XK3jChUqqMc+Pj6m3bt369OWLl3a5mfB5zcyrsMSJUokmH7gwIH6d6sNnp6epqNHj1rdHq29N5Zv48aN+vSW34tm+vTpat7WlhvzvXXrVpLr9I033tBfc+HCBbPn8F7ac/jtBQUFqb8///zzBL/Zjh076q/Dd5PYb96e319cXJzp0qVLpp49e+rT4jtNinGZ8V1ZWz+rV6/Wp8c6KlOmjM3lw+/OqHfv3gmmCQ4ONhUtWtTqtmnv7yQmJkatY1vT4rtOLuP2g23Pcj0bt0HjvteR+Rq/R+N6yZkzZ4LPYtyPWP6mEhsslz0sLMwUEhKivuNt27Y5fAxLjPE3ivlaatq0qf589+7d7Z6vI9ub8XfUsGFDm+vM8rdobUjpuramRo0aZvtYI2zP2vG5WbNmdq8fIiKizIqZ6ERERElAeQRj1jWys42dednKDjNmPiKztm7dug69L7I8tWzm4cOHS2rKly+fyvRF9h5KNCBrEGVnkDkLWmYzsk6RkQeoi6xBlp9WbgRZ54DsYJQiQMYrStagvjtK32gdH6Kzzl69elldHqxvZOojAxcZy8goTWvIRkXmOCArE3XvsS0cOnRIz+LTssO17HRrmegorYHSDFCoUCHV+SJaICDbFPAcspytuXr1qowbN06tt48//thqqRusJ3xfgOxm7btCawltu0ErgJkzZ6ryQ8hQ1LKjtfdF5u57772nZ1iizBDWPcalJLsWGdeWHYtqLToAGc3I/AW05kDrDq2sALJAjTWckR2LEiJo8YGM2t9++00vV4DPb6vjRfz2kGXZt29ffRy2dWQ+o9SDlhmLdYksTlv1nIcNG6ZKJKD1CaCFiWWdYWstPN5++201b/xukEWMrGtkLcOxY8esfq+Wjhw5om+TyMS3BetS+03hu03NEkDYvrFu8dtEB5H4bpHxj+3MEcjKfe6559R3Yez4FBm/GqwjrZQWWicgwxbflbbt/O9//1M1sAHTaZnxKK+FjHR8b2hZYtz2NI78TjBvLQscWeuYDvPG94pyIsZWSM6Ez4FSYBrsi5wFGdfYz2PfbzzOGNd/SmD7Rzm0d955R2Vyu6o1kSPrzJHtzRHYX2F7wvFWYyx15WxnzpxRJcYArQzQusEIx2W0zoHDhw87/f2JiIgyGttFWImIiEgxljIANN/XIPCA+qtGgwcPVoEb4+u0EimOQiARAaY//vjDrESKs6HZOS7sEfBFSRosu7HJOpqJI9gSHBysAl3Tp09XQYbdu3erMiJavWZjEB2BX3S+qgWcGzRooP7G50HpDAS0EFC8ceOGWj9G6EQPNePtgRsXyYHSESg3klQQBuVatAA5SlUgIIrSAcWLF1fP42YJgujoVFZrpo/AohbsRNBcg+AeAo1aUAPrAhBUHzBgQIL3R/AO9adtwWu0JvoInn711Vf6c8abHAjaomSJFoxGgBywjjEPbFsI+ALKVCBYjQALgj74/H///bekBgQtUXoBNYux7hDcBmxT2PaNsA3hBgG+b9xcsOxgEevB2o0q9FeA16LUwzfffKOPx00ilGfBdo8gmRYstwbb/KBBg9TfWkka3CTC9n/hwgV1c8RWTXjcRAKUrNFuyuD7QBAO88B3P2nSpAT9KRjhNwJaEC8xuJGCoC5eg+A2yk/Z+s1blkFJCSw/thn8PhyB3xLWBQLQuLGBAKXxu8D8jAFL/J60m1cotaLtf7EeO3bsqG6uaJ8L5VCwP7b83owc+Z0Y9+HYdlFvHOsRnx3B4tSE97N1TEoprDtsm7ihpHUai+0H76PVUbd2AyIpuHmF3xbWUVqUJXPGOnN0e3N0W8dgvNmC7dJScta1tX4UWrdurTpbBXT4i+O3JW2fou1jiIiIyDYG0YmIiJJg2RkbanlrgRZ7X4cLVAT9HA2kI+CKbFxkkyEIkVodwyFYi+BbYpBNiItwdFyGIDog4ILlQzYm4G/UEgZj3V7cBMBgCcEuBGwsAwlaoNkeltl19kIGXlLBCmTbaoFXBNGRia6NBwTREahEEN1Yt91YD924HoyZmMbMUls1jrUguy1aAB03HRAsNjLOc+TIkWqwpGVbGltaIJhm7OwWy5ncIDqCyMasS8vAFqC2NoJW2jaE7GYEuI3LgAA7AuSJ1fnG9mmNtp5R69kYOEIAHYw3cGzNw/i94TeIbVzL8MS6sxVEN34HqKuOwRKCe2FhYYlmmGvsCXojSIdOHHFDDDdVkN1vDYL7yMK2B7JxLfc9aEWAmu64iTBlyhTVEgD9J2D/aO98td+KFlQ0Bvy17wI34rTa8ahvbuwbwNpvyLgtIyhv63uzfJ09vxMEzbG/QdYwbjRhQL1s1KNGABrZ1qmVja7d5NI+i7Ngn67d3LH2HWjvhX2NPR08o4WN1soGrUu0rHb0SZDWkrPOHN3eUkNy1rURWsjhxqHWagrHdls3eZx5I42IiCijYxCdiIgoCcgYRtaxFpxBsEgr6YILUwwDBw5UHUcaIbCiQbkMBFmTE/BFRi6yWNE5GjJ0UwMyVzUot4KSFegAEdnNyEwHLcMUAUV0PokLdC0bTwtWoMM9R1krOaF1huZqxnIA+N6tBdEBJUiQeW8tiG6LsSM5W5JaDwg4Y9vCsiG739HMSGQpapnSKVlOW5DpjyzUxOD9UXZAg8+D8iXG4BWC6loAHescWcEI9qEFxJgxY9R4WxnQWvDMmOltLSPTkYBSStaJNUmVXdEC/fZ2RPrhhx+qwDaCaeik1xo8Z+/+COVyLDtNrFSpkv43Asj4PhD4QwAQAUZ7bjRaZtcbb5xY+y4s17uj30Nyvzftd4IAOcoJ4QYCOpZFCQyU79Juop06dUrdVHM2/Ca2b9+uPzYGvVPKsnWDre8AxyBjh5i2aC2xtG0MtBJIlt566y01YLs2tvByFuPNv+SsM3u2N+M4fE9Gyc3uTs661uB1KAWHbRFwboIsdFu0fYplazAiIiJKiDXRiYiI7GAMTiK7E5mjSUF2qjEI+9FHHyUoQWGsd2wLAlTlypVTAY3UKumiBcERCMPNANwkQFa5MZPPCNnoWpBEy2BHMMG4noxBNNRGx/JbDggeWguwOBLssjZfewZ7mswjW13LnEawTKs9rn2vyExF8AEBXGSlWguiG9eDVhoGjEExWwHHpNYD6syjLA0+D9bxhg0brM4TGdC21j8Cg7hJZKwdbAwGGZczNSAIpGVM4qaAlsGqlQIC43aIesWtWrVSrRecXdbCFuP3hvdELXONcd1ZMn4HCHjZ+g601hu2lC1bVv0fHR2tMr+TgrIlWt11R7LC7YGSFkltq7Yy+pMD9bq1ACvWlbat2PoNGb8PraWGte/N8nX2/E7wN26qYp+HljUIWF67dk3V/getLFBq3OTUytvgZhD6pqDEoVUE+k7Q2HuD0dHtzZjhjn4+NCg7ZevmmPGGnqPljxKD7Rs3xrQAOoLniQXQcT6i9eGCcwwiIiJKHDPRiYiI7PDBBx+o0iW44ESACGUCEEhBoFnLvrQGAfeGDRuqi1VkxeECFwFClG5AABqZtMhoTCxjDcEpBA5R9iIlkD2JjvCMEHBC6QcEi1H3HHVUUZcaWaYoY3Lr1i2r80INa2S4IainZfshqGksa4Hm5AhIIBiKzkFRTgPjEKBFABuvQz3x9N6hGQLiqO0LCIog0GssE4HnUYpEC5igZE+1atX055Gdr3XOie8eddXxnWL9WdaRdxRaBWDdIkCETFnUwEXwBi0F8L5aKRp0EIrvEt8rtl8EWZA5j+8dmcpYXtRxR7AaN4i6dOmitjd0GJuSeuj4XaC8h2V2PW4+aMHpsWPH6qUSsH5wMwDbDFpBoBwMaJ3fAWqoo5UEAlqOdmKZXGhxUaZMGfV7R9kc7bvGY1ulXLSMUnzP+G7wu8L3jhswqMuN7HvclEFQGvuAxKBcD36/gDrsib2nBu+LzhC1msjOqomO1gXY5vF7RykJBJFR618LrqO8iRb0dwYEHFGTXsvwRke6uCGBDFqt3rnxN4QSSFr/Alpnmdi+jd+bkSO/E/w+0KFohw4dVNAR2zK+R+2Gj7FVB24ODR06VA/Ov/rqq3Z/ZhxnUDIG6xY13o036PAbSeqmS2pITp1uax0mo8a4dmMHNwNQpgnbDMyZM0e/+WMtyzoxWFfY9+H7w+9J+71o2wSOPamxvSHgjpvPOHbiRgdq6eP7+fLLLxPN/tda3+AGCbZPBONRNim56xoBdPQ7gvWgLTd+o8Y+QxD4R7knDY692jaLfQwRERElwURERER2OXTokKl48eKIOiU6jBgxwux1ixYtMgUGBtqcPlu2bPq0gwcP1scPGDBAHx8bG2sqWbKk2eumTJmS5DIXKVIk0WVt2LChmm7s2LEJnsuVK5epdOnS+uMzZ86Yzbtdu3Zm00+ePDnB+69YscLk5+dn8/2xfNY+++zZs03pxZgxY8yWuXLlymbPf/7552bPV6tWzez5yMhIU/369W2ugwYNGpiioqKsfmfWdO3aVX9+3bp1ahy2OW1coUKFTBcvXlTjBw0alOj3j3lpfv75Z6vTGLc7e76XpH4f2ns+fPjQVLZsWTXOx8fHtH//fjW+RYsW+rTz589X486dO2cKCAhIMK969erpf2P7SWodWtvusF1b/h4st8dKlSoleG9vb299/dv6XmD69OkmT0/PJH+Dibl586bJ19dXTf/222+bPYf30uZVq1Yts+deffVVs/fq2LGjKaWS2qdMmjQpyXkYl9m4Ddr6jvD5y5QpY/M9O3XqZIqPj9en79mzZ4Jp/P39TaGhoVb3Z/b+Ti5cuJDodG+++Way92fG7cfW0L17d1N0dLQd35Ipye3S2noGbI/W1pGzGJfH8hiG9WTt92yLcR3bGlq2bGkKDw93aBkd3d4++uijBNPkz5/fFBISYnU/9P777ydrP5AY47qzNVhuh8bj/sGDB1P0/kRERJkBy7kQERHZCZmHyChGdh0yypFZjaxk1FdG/fM333xTNfFH2Rajtm3bqo7pUKcYmWYoB4DMu5IlS6osyEWLFiX53ngfy/k6EzIw0XEpMi7RmRrqH//1118JOoW0VtJFq6NrrcRAixYtVDYyMteRfY8sbZQ/QX1aZPJrmcbpmbEkj7V650k9jzIQyIzUMvzx3aMEC7YFNLVHpisyq1MCdfORwQ0o9/HMM8+o8hXDhg1TWfLNmzdX2ZJY/8g4R4YilkfLlAVkXyLjGlnEWB5kUyL7FhmNqQEdXmqljLTfBiADNCgoSM+6RWYlMp6xnpCtjvWHTkGR/fz6669LWsDvA5nMeF+sG60zXcs64dZgGTdu3KjKMiFzGb8V/I/PMmjQIPU5koJ9zfPPP6/+RqsIezPI0YJFK5HjzFY5Tz/9tPo9Y9vG+kBWOzJz8TnRgsDZ8PlRcxz7QGyXeF90VIkWIaj9juxmYzkZZPdi3aIUE35ryLJFqwrsc62x93eC5UA2MloXYd6YDtsjftfYfxr7ljCW6UhOZ6P43pDljOMO9p8o1YSWBY52Tu1OUrrOkEWOfQcyrnE8QksvDNr+JLW2N+zL0KIL3xemQ7kptOCx1ZkptiFMj7JLzu5fwRFa+SG0LkHrJSIiIkqcByLpSUxDRERElADKRCBggJIuCNqiwz2ijCIl5ThSA8rXaDdo8FvDb47SL9z0QAAXJbNQVxvBfErcO++8o25EIBiN8iTG0iPkXNgmtc6b58+fr0oUERERUeJYE52IiIgcgqA5ajqjfi3+BtTQJqLUg/r3aNmBAPq4ceMYRE/nGdWoaQ6ot54aAXS00Dh+/Hii0yCT3p1oHSOjjn1qBNDROufAgQOJToNs8+Rkwbub8ePHq//RAogd1RIREdmHQXQiIiJyyMiRI83KgKD8BzpQJKLUtWLFClcvAtkBZb/QMWnLli3l2WefTZX3wM0UrRNOW9ypwTE6BEWAG6XR3nrrrVR5jz179kjjxo0TnQYdfqI8UUY3ffp0NRAREZH9GEQnIiKiZEFtd9SGR61o1HkmIiJRfT64UwA7PUAdcmNNdCIiIqL0hjXRiYiIiIiIiIiIiIhs8LT1BBERERERERERERFRZscgOhERERERERERERGRDQyiExERERERERERERHZwCA6EREREREREREREZENDKITEREREREREREREdnAIDoRERERERERERERkQ0MohMRERERERERERER2cAgOhERERERERERERGRDQyiExERERERERERERHZwCA6EREREREREREREZENDKITEREREREREREREdnAIDoRERERERERERERkQ0MohMRERERERERERER2cAgOhERERERERERERGRDQyiExERERERERERERHZwCA6EREREREREREREZENDKITEREREREREREREdnAIDoRERERERERERERkQ0MohMRERERERERERER2cAgOhERERERERERERGRDQyiExERERERERERERHZwCA6USJeffVV8fDwUMP69etdvThERETkREOGDNGP83PmzNHHFy1aVB/vKo0aNdKX4ezZs2nyntr74fNrsF608VhfRERElL6MHz9eypQpI35+fup4XaVKFckMXHGuRJmbt6sXgDKfyMhIdUH2yy+/yL59++TOnTuSPXt2KVCggNSqVUvatGkjTz/9tEsvXF158MP6gPR0oaotS0hIiLz77ruuXhwiIkqF/fzQoUP1xytWrJAWLVqY3VSeO3eu+nvKlCnSs2dPlywnERERJX4Mt5QtWzb9GjO1l8PdrhnT6/W3I/73v//Je++9JxnR3r17ZcmSJXrAHAORKzGITmnq+PHj0qpVKzl69KjZ+GvXrqkBO8nvvvtO7t27J1mzZpXMBgfxc+fOpbuDuHZSVqRIEbc5ISIiouT7/PPPzYLomc2iRYvUTX8StR1s2rRJ/V24cGFXLw4REaVT7njNmF6vvx2xfPly/e/PPvtMnnrqqQwTS0F8yHiDyDKI/u2338rdu3fV3/nz50/z5aPMh0F0SjO4w9usWTO9mU3OnDnlnXfeUdnnnp6eKsCOzLdVq1bZNb+IiAgJDAxM5aV2DxlhXURHR6vtwNubuyUiIlfbsmWL/PXXX/Lkk09myuNY9erVXb0I6UaePHnUQERE6d8zzzwjH3/8sdm4jHR9lV6uGdPTeUtYWJhZy8FixYo5df7x8fFqvWfJkkXSm4oVK7p6ESiTYU10SjNffvmlWQB9586d6k4pAuu4W9q7d2/5/fff5cCBA6qWl7W6pOfPn5e2bduqJmkVKlRQz2/cuFHat28vpUqVUk3HfH19VWmYDh06yP79+23WPp09e7Z8/fXXUqJECXVAqFatmqxevdrm8sfGxsrw4cNVFhamr1evnipHYw+UrnniiSfUcmP58uXLpx4PGDBATCaTXm9UuwsO2nJqZW1Qk117jIPjr7/+qmqdYV2NHTtWrVvtecs7tInVdv3555+lcePGqqQO5oVpX3nlFXVHV1tfGiyfZb1UW/VkLZfXWp35P/74Q95//3111xjr9OLFi2qamJgYGTdunPpOcHKCATdbfvzxR7vWNxERpdyIESPsmu7kyZPSrVs3KVSokDrG4RiP7OW1a9eaTZfUcQyMxxgcwxs0aCABAQGqzieywwH/ly9fXr2ucuXKKthv5Mh5gS22jptoLYcAOzK88P6hoaHStGlTGTNmjNl0jhzH4uLi1LEU88JnxTHZ3vMLzaVLl+S1115T6yNXrlzi4+MjOXLkUDdBtGbQRjdu3JAuXbqo8xKsI/yNcdbYqomO+T7//PPqYj0oKEitZ2QfYluwVpf01q1b8tFHH0m5cuXU5wwODpbHH39cJk6caDbdmTNnpEePHmpeWMcI4Hfs2FGOHDmS6HJh3eLcEK957LHHZMGCBQ4vQ/369fV5nj592uy1KDeoPbdr164kvxMiIlfAPhPXmcahdu3aZtPgWPjiiy+qazDsu3H8ef311/VrMc3Bgwelc+fOap+JYwqOLZh/y5Yt1bFW447XjM64/obRo0era++CBQuKv7+/OrZgfX366afy4MEDm+cWV65cUdfcuAbHMRTHORyjHIkhaMu3bt06/TXFixdPsC5xnoTvDOcHmA/O1/D8iRMnzN7P+B3NmjVLnQfiWIzvfdu2bQnWx8KFC6Vs2bLqM+P4iTgOAu7Dhg3Tz2lwU8e4jmHmzJkqBoS4Cr4zfKc4Z+vTp4/ZuQjWF84pNMhItzwfSawmOs4XcU6F8xx8Z1g3b7/9tly+fNlsOuO29ueff6oYFb5PR2M+lEmYiNJI8eLFTdjkMIwaNcru1xUpUkR/nXEeGA+YlzbOcggICDAdPnxYn9fgwYP150qXLp1geh8fH9PGjRv16bt27ao/V7Zs2QTTFy1a1BQTE5Po8q9fv97k6elpcxnx+tmzZ9t8XvuZrlu3Tn9crFgxk4eHh/4Yn+vMmTP644YNG9pch0avvfaazffE/Izry3LQ1r9xGnwOjXF5sR6trVPj96m9Z3R0tKlJkyY237d///52bztERGQf4768evXq+t9btmxJsO+eMmWK/rrt27ebgoKCrO6vcZyaPHmyPm1SxzHQHoeEhJhy5syZYH6ffvppgvfB+9+6dUt/n+SeFxiPYdaOm99//73N+YaGhurTOXoc6927d4JpgoOD1TmG8fiYmK1btyZ6HjF37lx92qioKFPVqlUTTFOpUqUEx3gwnqNo3xO8+eabNt8vb968pqtXr+rTnj9/3lS4cGGr0xrPWXbt2qW+e2vTZc2aVW1v1pbL8nwCA869jh496tAyGOc5fPhw/bUPHz40BQYGqvGPPfZYot8FEVFaMx7LjNdd1vz+++8mPz8/q/vCfPnymU6fPq1P+/PPP9vcz2Mf+9dffyV4f3e5ZnTG9TdYiyloQ+PGje2Ka2hD586dHYohGJfPctDW5aRJk8yW2/L8aceOHVa3I8vlw3sltj607adHjx4J3qdevXpm66FZs2Y2lxsxFxxzLdeX5aCtfxy/jduFBt+/rddabueJbWv2xnwo82AmOqWJ+/fvm2X0GJuH407g5s2bzQZknFtz9epVdbcZdwi1Zmo1a9ZUtbB+++03dRcW2eRffPGFeg53f5FtbitzDndJUUMMd0K1u9m26rdheswXd6Bx9xZwtzOp8jPLli1Td2Rh5MiRKjMPnX/g7jTuUuOOp1ZvFHeXNXisDZaQpYVMONz9RSYY7vw6Cne2cYcZvLy85IMPPlAtAb7//nvVMgDLhaw24/tj+bRl0jICUwLbBEr6rFy5UmX34S78N998o2cvImti8eLF6r1Kly6txiHbb/v27Sl+byIisq5JkyZ61hpaYNmCmDcyhNCPCbRr106VZRs0aJBqao3ncUy9cOGCw8cxlIBDVhKO7Z06ddLfD1lR6FsFx25kYwHef968efprk3tekJSlS5eq/9GEfOrUqepY9dNPP6nsOGPTaUeOY+gjZvLkyepvrDNkVuGz1alTx2o2ty04PiMbDsf2NWvWqM+NjmBz586doFUBWuLt2bNH/Y1WAzgXwPeAczVHoBN4HLtxnoPsNBzLsS6087UZM2bo0/bq1Us/t0Pm2bRp09T0WBfaORW+365du+odvGFeON/Dd4fzFCwftrdH91oSnk90795drTtsv4BzL0eXAS0YcC4C+G41+D7RdB+QvUlElF5h32/MqDZmJeMYiP1sVFSUOpah/xPsZ/v376+eR3Y09pUaHLe++uordZxGNjP2hehcHFm92MeOGjVKTeeO14zOuv5GR+s//PCDuo7GsRDnHlqfMjgWozyeNQ8fPlQZ8zgHQHY4IEag1fe2J4ZQtWpVtazIjtdg+TDuk08+Uedf6HAUx02cY+C1OE/DsU47f8K2Yeu4ilYImB7xAWSWW64PvBbPayVVsP1Mnz5dtfjC95E3b141/u+//5ZDhw7pr0XWPc498FqsM/yPFnGAVmeItwC+T2NpIpwDaN8Ptjlb8L1rLQSRTY6KCPhekJVubTs3wjpLTsyHMhFXR/Epc7h48aLZ3bxjx47pz3377bc27yxa3oGcNm1agnlHRESYhgwZYqpYsaLKMLOcF7KtrN1dNd7pvXPnjtlrka1keVeyb9+++vSjR4/Wx48fPz7Rzz5w4EB92oULF5pu3Lhhc1pbGeNgvPOLbKybN2+aPe9oJnqrVq30cR999FGin8FaZpomJVkFL730UoL5Va5cWX9+wYIFpk2bNqlh2LBh+vi333470eUlIiLHGPflAwYMMC1btkx//M8//1jNRN+9e7dZVg+ywjRt27bVn/v666/tOo6B8fh9/PhxNW7nzp36OByrw8PD1XgcU7Xx7777borPC5LKRO/UqZO+DGvWrDHdvXvX6rp05Dj2xRdf6OPat29v87wkqUx0mDNnjql+/foqk9ta1pm2vM8884w+DhlqmtWrVzuUiY7vr1+/fioLz9/fP8H7tWnTRp9Oy6bz8vIyawlgtGfPHv21VapU0dcbhjp16phtj5bLhXWu2bZtmz6+devWDi0DGLPokBlvmXVvzG4nIkoPEssEN16LLV68WB+HY4FxP6u1fsLx4/r162r62NhYda1bo0YNlbVseWzJnj27218zpuT6Gw4ePKjODwoWLKhatVuu+2+++cbqe+G70DRv3lwfv3fvXodjCLaysceNG6ePx3mZBudrOG/TnsPx1/I7sswet1wfhQoVMsXFxanxY8eO1cfjPMRaS7slS5bo4xFrwbEW2ezWWkW89957SZ6DJPbZ33nnHX3c+++/r0+L7Vp7P2zL2vfpjJgPZR4Zp4cJStdQx8sIdcxQr9JRzz33XIJxyAjCnUVbtIwmS6iXZlw+3LXWMrNw51W786hp2LCh/jcyt5KavwZ3cJH1hjv+2l1f1JJDfS3cAUUtVUfhtahLlxLoyFXz7LPPiitY+z6Ny4X6tdZY1kUlIiLnwnEBGU44LiKL2fI4brm/Rl1p1Mw0ZoMjK9pyOnuPY6hfiUx0ME6HY7WWKYzantaOxck9L0gKMqDmz5+vMvm0YzdqZuL8ABn3WmekjhzHjK30atSoYfO8JCk4z+jXr1+i0+Bzowa4rffEd2Yv1HHHOkhs+bT1jJZ8WjYd6pGifqo1xvW2d+9em63ssO5Q/9aRczR7lwGQ0Y5MOi0bHb8DZLgD/tayHImI3KVjUS0j2LifRZ1xDJYQC0crKbT2wnFlwoQJTj+euuM1o7XzFtT6rlu3roSHhzu8jpI6bjkjhmBcR8bYB87XcDzTvn9MZ8xmtyc+gOMwstvBuF6MHbNbO09D9jvWmWX9fWduV7Y+N5YH5wDYLrCd49zA8twnuTEfyjxYzoXSBDrgwg5LY2zWhM4dsBNDBxlJ0U4ANGiWq10o4z3QHApNgjBotIumpFjrdNMInX5ojL2BW2v+ZIROrtABFZqgYSeOC+Nr166pJk4oI2OriZcj68Fy+XFxa2SrszBnsPW+9ryntc9hD61JNRERpR40BdbKmKBzMUckdUxNav9vDNprF2mAILA12rHYmecF1sqXoEkyOr3ExSc6zMJFIAKtuOiy7IgypcexpNahEcrXaNAsH82+0dxZa2Jtz+d25P2wHrQAOjp6Q/kAdDKHzsrtfb/ksrbuknuOZg3O1dBxLeDz7Ny5U3XcCi+99FIyl5qIyHUdi2o3pR3Zz0ZHR6uyV9p+FSXDUJ4ExxYtOOrIPtbdrxmtLQOOfVoAHWXYUOYF60crj5PYsTCp41ZqxBDSw3kall8LoKPTeCQnYJ0ZS+2l1vlDasZ8KPNgEJ3SDGpfaVBbLSwsLMU7Pe2iBnAweeutt9SFLOq0JWXHjh3636g9duzYMf2xMeCfUtjh4mIMddvQqzXuYmq14XCAwMHW2gEosYOHtZ2/8UCGOl8a1Ji3dgJhbAmAOmSJ0d7P2jLZel/UrEuKtc9hXC4EJLD+LAet/h0REaWeF154QdXdxH4XF3KJ7a8RUI2NjdUfG+uQWmt55kjA1hEpOS9ICtYDLpIRVNi9e7fKpsL5DCA7XTvuOXIcM55v/PPPPzbPS+z93MiaQi1P9D2DQL9xfWhsvacj/Y0Y54vAMmqZ2socL1mypH5+g/WBDEdrjOsN35m19YbzmTfffNPu5XR0GYzZ6Fq/PVqGP7ZZ47ksEZG7Me5nURvd1n4Wx8+bN29KZGSkmrZy5coq4a1Ro0bqGHLr1q0Mc82Ykutv47EQ2f/oswU3LbS65mkVQ7DFuI6MsQ/0A2dsSeaq87TevXurVgRYZ9q2ltzvx57PjW361KlT+ufDuQGRo1jOhdIMOq5EthayxHAQQBNiXJjgIg87TeOFnL2KFCmi/43OTpAxhM6nLJuwWYNpcfcT7z9x4kQ90IzHlqVcUgKdWiADrmXLlqojq8DAQLOOKdBEy3jnE510aFllaCaFEw5jJlliTd9x8YyDA5omoZMTNDlGRxrWvPzyy3onaVhGBD/Q2QZej05O0Gmatn6xXDhZwo0PfIcYj7vTyGowHnzQ6Ssy//D+WqeljkLTtX379unNyHAnH83lcSGLi14sMzob0zrIISKi1IELDBxPcbywBk1/URYDzWKxj8b+G/tmBGORaQToLKtt27ZptswpOS9ICrLB8DnR+TbOE5ChZOx8TDueO3IcQxN1rSUeyt+gI1cc+43nJfZ+7hMnTqhjOLIFK1WqpC68rQU6nn/+eb0J92effSb+/v7q2I2OwBx5Pw2WGxfAt2/floEDByaYFs28UV4AN+yRfYi/0bkZ1iE6GsMNCXTKhiANMu/Q6mHDhg0qMI8m7Gh2jk69cCGM7Qrv4yh7l0HzyiuvqM+CTExk3QM+ozPPD4mI0hqOX+hw+vr166qzSOwbMQ77Rexnsb/D8evw4cPqWg+dMuI6/cCBA+oGMsbhOJVYdrW7XTOm5PrbeCxE2Ruc8+AcaObMmZKWMQRb0OE7zjEQNEdHmYMHD1adsCKDHusJkCyB429aMa4zfPe4KYPtwNgBuq3McNxwadCggdou8f1YKzWolfXTyhDhfKpAgQJqGxw/fry+3nCjKKXlcSmTcnVRdspcDh06ZCpevHiiHZ9gGDFihF2dfUDLli0TvB4dYVjr2MTYWUalSpUSvM7b21t1mKExdjJhHJ9UBxdGw4cPt/k50cnV5s2b9WnR8YXlNFonobY6XTFCB6GWr8+fP7/qZMzaOjR+PsvB2CmJsYM4y2VAxySFCxdO8HzZsmWT7CTGuE41UVFRpiZNmiS6fRg7oyEiIud3LKpBp2IlS5Y02wdrHYvC9u3bVWdj1vbV6LRp8uTJ+rT2HMesHbttdZxta37JPS9IqmPR7t272zwuoWPNU6dOJes41rNnT6vzCw0NtXpMtsbYqZc25MqVS3X6aTkPLJ+xQzZtKFWqlNV1ZO2cB9uFtfMo43o2flfnzp1Tna5ZWxfG6dCRp/GcxdqQ2HIltr3Yuwyadu3amU1j3JaJiNIT47HM1vFVs2LFCqudOVrb/xs7hjQeK/LkyZNgn+yu14wpuf7GccVaB+bGY6Hx+GQrrmHtszoSQ7DVsSigA3FrnY1jwPnbjh07kjwn0thaH7aOx9bmh87hEZ9IbJ0Z523sDNQ4aOvJ1mfv37+/zfWHTlVPnz6d6PpP7HNR5sZyLpSmcKdz//79quYVmv3i7h8yxFA7C3dA0UQX2VGOZEMhcwjN0VCbDdnYyB5atmxZkq9777331J3JEiVKqLvGWsdRaKbmTC1atFCfC9lVuJOKz4vPjdqquJuMzkE0uDv8xhtvqLulyWlChYwyvB7rAXer0aQMGQW27tLOmTNHrT80m8Y0WA+40407+8a7vlhPaGqFzAVLyBBDczI0ccfrkQEwdOjQRDuhSQzmgbvMeD06+kAHcrjbXKxYMXUnHnf227Rpk6x5ExGRY3DMSuyYjP00Sr3gOBwaGqqys3H8aN68ufz555+qnEpaS+55QVJwbMR80coLx0ysG9Sebd26tcpI18qkOHocQ+bboEGDVG1xTIfzAjRBd6SZMc5pkMWFDC/Uase5DDLx8+XLl2BaLN/q1avV58H5FwYc4411423Rzk3w2ZHVjfMMrAucH/Tt21dmzJhh9XU4t0DTcWQKohUgPieyENGaAZlyxg5q0akoWtNhfWJZ8R3iHArjUlLOzd5lsCzpAtiutY7diIjcGa5N0QIcx0Zct+FaDsdL7AvRSnzhwoX6tGjRjI6zcXzC/hItmbAfRgsma9zxmjEl1984ruBcB++PdYK4Avpief311yUtYwiJQSekOOajBRZej+MZPitae+H8zdjBeFrA94TlQdk5bFM4dxw2bJgarMG2ie0GsRpb2501KG23YMECFefAeQ62v6JFi6oSMmh9hu2EKDk8EElP1iuJ3NCQIUPUwRpmz57NkiBEREREiUBQpE+fPvrfuADNDFDmDgkJKOmC4MPvv//u6kUiIiIiIhdiTXQiIiIiIjKDGrnXrl1TdVQT63wso0HQHB3ForUe/gZk7BERERFR5sYgOhERERERmUEJHGNTeJTka9KkiWR0I0eO1FstAjrPtVbuhYiIiIgyFwbRiYiIiIjSievXr6uaqqi4iJqxzqitmhKoMYt+bCZNmiSenpmnOyXUasXnRgkb1JAlIiIiosyNNdGJiIiIiNKB+/fvS+PGjdX/nTp1UlnRw4cPV51hEhERERGR6zCtgoiIiIgypFWrVsnWrVulVKlS0rlzZ0nvtm/fLu3bt1edd6JTy5YtW6oOLW/duiU5cuRI0bwjIyNlzJgxEh8fLz169JDQ0FCnLTcRERERUUbHTHQiIiIiynBu3rypOsK8ffu2eHl5yZ49e6RChQqSWQ0ZMkTV+vbw8JAOHTrI//73P1cvEhERERGR28g8hQ0pTY0dO1ZdpGXPnl0iIiKcfhGIeWOYM2eOU+dN7gP3/0qXLq22A2TsERFR5mQ8L8Dg4+MjISEhUr16dbl79656Pn/+/NKnTx+H5vvLL79IpUqVVAAe8z169KjV6U6fPq2ef+GFF+T8+fPy1FNPSZ48eVQtcQTtly5d6tD7Nm/e3OzzOBrsNr4WNcz9/f2lQIEC8sUXX6jnR40aJfPnz5f169c7NF9kxSMbHvNFqRlbunTpoqbZv3+/fPnll6pjzoCAAMmZM6e8/PLLcu/ePYfel4iI0t91WMWKFdW+Hi2b0lKjRo30Y9zZs2fVOPyvjcPzzoRYBmIamDdiHBnZwoUL1edEPyDnzp1Ls/fF+Yj2/b366qv6ePytjXf0nCUpn3/+uZpv3rx5nR6vooyNQXRyOtTxRHNhQGdYaI5MIidPnlRNybGj9vPzkxIlSsiAAQMkPDzcKfNHU++PPvpIGjZsqC5WrR2IUmLDhg3SvXt3dTGMi/LUOKAhS3DgwIFSt25d1czc19dXcufOLc8995xs2rTJbFq8d9++fdXfM2bMkAsXLjhtOYiIyH3Fxsaq4DkuquPi4mTw4MFSpkwZdbxyJCAdExOjAuO4YZuYFStWqP+fffZZdSxGsPi7776TX3/9VS5duqSyvnFuZG+nomvXrjUbl5KMcQQ6UMbl8uXL6n8YMWKEOo7jpgLWlb1wPE7qnAKlYv744w8pXLiwugGBi3CcC6IkTZs2beSnn35SQXwiIkobO3fu1G8GBwUFJbhmWr16tX5dlytXLnUcSgpuxB48eFD9/e6779qcrlevXmY3dleuXCnuBrEM7UYBguj2Hs+dBcfpqlWr6utw/PjxZs8/fPhQSpYsqT8/a9YssxsL9t5UwPEbSQeA43WRIkX053744Qfp2rWrlC9fXt1QQCwD74lr8Rs3bog76tmzp0oyuHbtmupAnMhuKOdC5EzffvstSgSp4ejRo06f/+DBg/X5z5492+QO9u7da8qWLZu+3MahSpUqpvDw8BS/x549e6zOv2vXrk75DH379rU6/3Xr1pmc5c0337T6Hhg8PT1Nv/zyi9n0WG9+fn7q+ffff99py0FERO7DeF7wzDPPmDZt2mRaunSpqU+fPiZfX1/9uVatWiVr/g0bNlSvP3LkiNXnmzVrZvLw8DBdvnzZbHx8fLypWLFi6rlr167Z9V6TJk1KcPzDce7OnTt2L6/xtQsXLjStXbvW9N1336nzDW081sv27dtNjsIxH6/v2LGj1ee3bt2qnn/rrbcSPDdnzhz1XO/evR1+XyIiSr533nlH3/8///zz+viIiAhT8eLF9eewn7ZHtWrV1PS1a9e2OQ2OxTj+GY9Jf/zxR4o/i3ZMxnDmzBk1LjIyUr0fhv3795uc7dixY/p7ItaR1nbu3Gny8vJS7581a1bT+fPn9ecGDBigL1vjxo318Vg3GIf1ZY9ly5bp81m5cqXZc9r1trUB5zk3b95M0efTzi0sYxfHjx/Xv1dHzoPs9eKLL6r3zJcvnykmJsbp86eMiZno5HSzZ89W/+NOZVLZW5lFt27dVFYcvPHGG6ppd4MGDdTjvXv3yrBhw1L8HsjaxjyRyf3aa6+JsyGDvl27dvLVV1+pGrOpJV++fPLJJ5+oTLZ58+bp2xDujvfr189sWmRTNG3aVP2N7DZHMuqIiCjjQRmVJ554Qp5//nmZMGGCKsmiwbHXmOWNY4a1wZHugtAEGBnu1apVU8cvow8//FDOnDmjWnEhi9sexqxzrWRKVFSULF68WJIDJW2efPJJde6BTkvr1KmjxkdHR8v777+vT4djrLV1gUx+Ryxfvlwv/WJ0/Phx1VoOx+233347WZ+FiIiSX7qiUKFC6u/ffvtNPzYi8xglyaBJkyYq2zgpBw4ckF27dqm/27Zta3UaHLeQvY3jKUqbpTZkRuPYjwFlZpwN176IbYArysniWK6VpEMmvFbKFGXTcG0OWM9oBZfSGA4yzXHeYISMdqzbqVOnqpYLw4cPV7EHwHnON998I6kBncJr32u2bNmcPn+0NoQrV664ZSsJcg0G0cmpUAt09+7d6u+nn37a6jS4iEXgU2sKhCApOrpCUyRLCxYsUAcsra4oHidm8uTJqkwKmubUrFlT/vrrr0RraaFECC60cXGLA0GxYsVUoBadkFl2ToYmP2jWhOlwEYiD6YsvvqjKnCRmx44dqkwJoBQKDj54T1woY5lg5syZqtl4SpQrV04tC5pJ16hRQ5wNF7+ok4b1g+8uNaBW6qlTp1RTc9SExfpFc0ENmoWjyZURas9qB7+tW7emynIREZF7QokV7WYr/Pzzz3ozZ9ROtzbMnTvX7vmvWbNGBQvwPhocz3HugQtbHNdw3LcHmthv3rxZ/Y2m27gpbrncKYHzF2M9V7zXxYsX1d+4+W5tXeCcyhEobYNzMOMFOI7NKNOGcjKrVq1SpXWIiCjtZM2aVV0na9555x113fj111+rx9hv2xuANd7UtXW9jyAr+hHB87Vq1UrWMuMmLoL8KPGJUqWNGzeWffv2WZ3WVk10Y58puN5GzAF9pAQHB6vrzDt37qgybK+88ooK0qLfD1zza+XPrF1z4gaCK8qI4vpYK7GybNkydY2McmlaEtmgQYNU0Dk5cGMdZdcA6w/Hf8v4DeImb775pjqn+vTTT1WpHmPJIHshgRDvgW2uYMGC6juxlQhnK46jjStatKi6kYBEQmwjOL9YtGiRmgb/I46EeFPlypVVXMiS8fwwuckKlAm5OhWeMpZ58+bpTXF++OGHBM8PGjTIZlOg+vXrm6KiovRpFyxYkKAJGIZKlSpZLecybty4BNP6+PiYypUrZ7X0yPTp01WJEGvLUrp0adOtW7f0aZ988kmby/3JJ58kuk6++uorfdpu3bqZPYfmT9pzKMditHHjRtPYsWMTzG/58uWmadOmJfqeU6ZMcXo5F6NatWrZVc4lJZ/B2MzQuL7v3buX4D2050aNGpWMT0NERBmlnIu1Y57x3ANN0AHnGzjuWhu0Zsnnzp0zLV682FS+fHn12okTJ5pWrVplNu8ePXqo59DUWisz1rRpUzUO/+/YsUM9Z0/ZNhwvteX8/PPP1bhSpUqpx97e3naXhDEeM7Wm7pro6Gi9STgGNN/WPqu1dXHo0CH9tfjsw4cPV6974okn1LrB6zQXL15Uz7Vs2VIf9+uvv5qyZMmiBpQJwLpIjVJ/RESUtPbt25tdJyfnGurpp59Wr8F+3VoJDJRTwbwDAwPVMchYfsWRci4o/WV53R0cHGwqWrRogmOcVrrEsnyJ8fygRIkSCebXvHlzU82aNe26vv/+++/153/++WdTSsTFxalSpKdPn3bodStWrLD6/VWsWFEd340cKeeyZcsWfV44zjtafq5du3Z2vebEiRNWS9wa4zvG8zj8bS3moI0LCQkx5cyZ02xeiB99+umnCd4jKCjILL6j0coZIf5DZA8G0cmpjBeqqItphAtJ7bn8+fObZs6cqept4WJLGz969Gg1bWxsrCk0NFQf36lTJ3XQeO+998x2hloQ/fbt26aAgAB9fK9evdT0Wp0ry50vLvS02l7YoaK2GS4OEeTWpu3Zs6eaFhe+WjC/atWqpt9++02dAEydOtXUtm1b08iRIxNdJ6jJqs1z4MCBNoPRuNDU/P3336reGZYtLCxMH4/1gpsCWJ7E6sGnhyB6Sj+DtRMW3GixhHlrz7/yyisp/GRERJTRguiTJ0/Wny9ZsqTd88UxyvIirEiRImbTFChQQJ3ToP65ZV1Pa+cf9tSYxYD6q4DzBm0cPkdKg+iQJ08e/fkff/zRzrVhUp/d8nMZj+Oou45xOAfRGIMn1gIcRESUdtB3BwKPlgFMR+pBFypUyGbQEcFhLSg9fvx4NS45QXT0QaJdfyPpbciQISoJC32QWDvG2RNExw3kMWPGmObPn6+uT7XxuF6dMWOG2fVzrly5Eg00I+aREps3b1afC8dV481oe6BPEuM6wHws4y6OQlzG0RsETZo00V+D19sDMR3tNYirLFmyRMVhjHEcR4LoWl1+xGeM89b6wcE2g5v+2jgkQ9i6KYTtDXEKoqR4uzoTnjIWY+/MliU/ULPaWCNcq6uNJlNo/gs//vijDBgwQDWTunTpkhpXoEAB1SO0t7e3tGjRQpVH+fvvv83m/eeff8qDBw/U36hLOmnSJPU3mpCh6ZHWXFmDsiRofg2o812lShV9udA0CvNC02nMB++L5kLYX6PHcvREjaZSGI8mTfbUS9VotcOsPdamQ83SZ555Rr0fmlWhyZkGPatjHJosocYqmlp17txZ0htnfQZsB1r9NzTF0pocGhm3M3ftHZyIiFKPdj4BjtTURDNiDLagVFtYWJg6lmnl2dBE2ZGa6poTJ07oNWZRz1U7R2rfvr2MHj1a/Y3zkrfeektSAk22jcdKR9YHmssnRjuXM9ZDtyyjR0REroO+O1Ay09j/Buqg47rWXtoxxFp5T9TGxrV67dq19Ws4W1CiE/1lGOGYhGMg6rZrx1LUXR88eLD6G7WxERvQrvsd0bFjR9VXCXz//ff6Meu9995Tx3GYOHGiHDp0SH1G9GdmPEY685qzXr16Mn36dFWOBeXPUFoHZWvsocUrNChZgvWdWjEca1DORetjBu/dpUsX/bl//vknQTkcfKcoh6v1m6LFfVCOVivLirr9yYHvErEZxBu07RqlXRA/wnuiZLBWKu/kyZMJXq99XmxvKOGLvnWIEsMgOqUay4tI40Fy5MiRarCE2mmgdXACCHAbD+yodW4ZRDdOb6y7htehPrhlEN24LOhEQ+tIwwgHTlwco1YXaqbhJgA60sDOHoFfHLCee+451TFXYhehgYGB+t9a4N54MWucDjv5Zs2aSXh4uBqndT5qC056KlWqlCodqCSXsz4DDna4EMd88D0ieIAbJJaSE6wgIqLMw3jOoN00dwZrQePkMgY00GmbFpS3PC7ihoC9F9rWoD45OhF19vrA+Q0uqHE81zqvIyKi9JfoZNnHGG7U4nosZ86cDs3L8hoMfYqhLjeukxEg9vRMvPs9JFUhIGzUsGFDdfPVeG1v7OsL19zoT03rb8wRiCFoUPvc2GmnBglzGtRLN17jO3LNiWAx4gT2QH9g6OAS301SUDscCYdGOGdAINkYyE6JpD7nBx98oHdmihrkuOFhjNUgQRH9mBmtW7dOTYtOUbW4hxZAt/xuHBESEqLXgTd+p9hGEEC39p1aYiyBHMWORcmpjDspy8457YEDg2Wg2ZK1C0tHnneElh2OIDs6W0GHoOhkCx2doFMMdJqCu9qJQYcXmqtXr5o9h7uuGnRqSv+1LNAC8chAR8cgbdq0sTqtcTszbn9ERERLliwxy4ZO6pjtCFwko0WZ1tlYStjTcSgu9IzZZ47C+ZXx4hudfSJRwBlwgYxzJmMHq0RElH7gOrtHjx76jVStk8rr16+rpDB7addbltf6SEDDcQCdayM5Suv8EVnWGrRURuAzJZJ7rW8MiBsD/Ohk1N6bBK6+5kTwWutctXDhwvp4fH8pyY63J4aD7Qat8LUAOm6a4/wqd+7cklKu+k6NnxfL4OiNJMqcGEQnpypbtqz+t2VzGa1pshaU/rcmv9mAAy+CpsWLF9enRbAaQWuNtbu0CGxb6x0aJwvWeos2Lguah9laFtzFBNxdfeONN1TP1Phc2Nni4lML+BpLtlhCszNjBpi280Y22fnz5/VmRMhsRy/Vq1atUjt+3KFFKRrL5UJzahw0caCYO3duuspCh5R+BvSMjTv3aKaH1yPTr1WrVjbfz7idGe9oExFR5oPm4cjYRmYUmpIbg+Y4tjgj4K0FHXB+gay5rFmzpmheuCA+cuSIHtT49ttvzYZPPvnEoWC7EZpVI8CNRABkemnnUMgU1C6E01tWPhEROd/YsWNV1rKW3b1t2zY9exfXY1p5Dnuv95FtjGvt5EK5NMtrRO2mtzEWgOOYMVB/7NgxcQVHrjlxQ9lafME4zJo1SwVu8Vl//fXXJN8f2flDhw7VYxOIS7z88svqMQLoKEuTGjEcwPf8yiuvyLRp0/QSLviu8ubNm2BaXOdbflaUukOZFK2FPmIn2nkP2JOFn1q0z4v4EMrOEiWF5VzIqVDfS7N79261s9W89NJLqk4aYCd/69YtdQcTzWrQjAnBaFw84oCCsh1oroxAM0qqoHkSDhI4uFuWcgFcFKP2FQKvqMP27rvvqkxm1MKyLOWiNTMaOHCgyspCEzYcwOrUqaNef+bMGXXBibIkKN+iBelRj61y5cqqDhsu0jEd4MCA+RjLthjhorVq1aqq2RkO+riDiwMrLl61gLpWG1wrR/PHH3+o5UcNeLxGqymOmwkYd+HCBZk5c6ZZLXEsO5rFgbGJG05wkMmtnTBpWQc4mGmZAfgsxox5aw4fPqwGwHenwTy0O99Yryn5DKhVj9I5mAbfCW5w4KaKVsdM+wwYpzF+VuP2R0REmQ+OPRgsIbhr7JvFGe+DrCxnZF4bS7ngOPr222+bPY/3mTp1qqrViWACzpmMyQOJQU11Swj6Y12ktIaqZRAdmWzOnCcRETkHjhtoQa0FYFFuBfXRx40bp/f9gWtUBNmREJUYXG/huh3Xv6gfjutjQEDeWv9VqDOO99feQ5s+MbjprbWc+uWXX9SyIz6AeSWWvJaanHnNiXgG6qEjqQxxB3vKtKEfOcQnALEOlGPD+l65cqW6FkeNccRMkpMsgHWbJUsWVcscMRxLiIMgOQFQsm3IkCHqu7esZZ8YJM/hnElrUYc4Ecr/IN4zfvx4cQXEobSYDuMIZLckux4lclC1atVUD8cVKlRI8Bx6sjb2mmw5GHtjRs/Q1qYpWbKk/vfs2bP16ceNG5dgWh8fH1OZMmWs9uo8ffp01Zu1rWUx9uyN3rxtTYdewpOyZ88eU7Zs2ay+vkqVKqbw8PAEr9m4caNp7NixCcYvW7bMNG3atATjjb2S2xqM68vYU7rWs3lijL2b2xpS+hmMPXDbGiyXtWXLlmp8vnz52KM2EVEmZHl8wrE9KCjI9Nhjj5nat2+vjjnx8fFOfU/MF+916tSpFM+raNGi+rJv2LDB6jSvvPKKPs2IESMSnZ9xXXh4eJh8fX3VMbJOnTrqPOzy5csmZzp06JB6LywjERGlP02aNNGPC/379zd77qmnntKfGzBgQJLzOnDggD79l19+meT0xmvOP/74w+5l7tmzZ4LrQH9/f1NoaGiC60LjdbDxGt54fmC8DjZecxrjA4ldH5cvX16Nr169uiml4uLiTP369bP7HOL777/XlwvnDBEREfpzP/74o/5c8eLFzZ5zRNu2bdU8smfPboqJiTF7Lqnrc+M6T8zx48dNwcHBCV5fqlQpq/EgW9+TNq5IkSL6OFvbAF5nbd6wcOFC/bnly5cna71R5sNyLuR0WgchBw8elBMnTpg9N2zYMFVDFL2Co+YUsq9x5xUlT5ARrjVRgk6dOqlmy2hehJqjKK2CLHVj5rIRstsnTZqkaosjU/nxxx9XmVHoxEKDbHUN7v5u3LhRdeSBpki4K4//kTmOu6KTJ0/Wp0UnqMiqRu1QzBsDlgc9fCN7Oim4U4xm38jGR1MmfB4sZ//+/VUmt9bxhVH9+vVVxx2WcAcX9exSytixmDGz25lS+zPcu3dP1qxZo/5GSwU2wSIiynyQEWVsNozWTOhTA62g0IEajjnO7C8FzZqRhYfzC2OT8+RCFpS27LY640anYdo0xvIu1hjXBY71yBa8fPmybNmyRZ2HIfvQmVjKhYgo/TKWasH1J1r6GqHcl3aNjJbS+/fvT3R+FSpU0DvjtKcMSXKhnBmuydGaGVnSyBTG5yhZsqSktePHj+uZ11rmfkogKxvr2p5zCLRC69evn/54ypQpZjENxEZQa14r+YJzopTEcFC2FtnxqQGdgGLeONdB/AHnI2hxgO/aFbTtF8uB+BSRPTwQSbdrSiI7oddlHKDRrAhB4i+++CJN3hebsuVFcnR0tDrQonQInkMNU3YY8SiAjvWAJkwI7DuziXtawo2O3r17q4MwbtigeRkREVFqQkk3HH9Qqi2xPjsyC9yoQLk3JDMYO/kiIqKMCSU5kPAGCC5n9H6pENNATXl0ookb37bKuLp7fACldvF9dujQIUUdmbsD3JxA7AAlchCvwndMZA8G0SlV4CCDHRF630ZN8rQ40CAQjPpiqP+JwPmVK1dkzJgxej1w1AdD5hg9qumGTH1kwBvrlbsT7LqQBYjMAATSUSOPiIiIiIiIUvc6DAFXtDxH627UWM+oUIMdrdGRfIYYh7VW1hkFWtgjgI7W3chqR832jOrzzz+XTz/9VFUJwI0RY3Y/UWIYRKcMY86cOXozJEtoooPOKe3tiCujQ+cdyBjL6CcCREREREREREREKcUgOmUYqN+GWp+oPX716lVVawx1xlq0aKECxbjLSEREREREREREROQIdixKGQaalKF0y7lz5yQyMlIePHigmpihpAsD6EREREREqWfSpElStGhR1QlgrVq1ZMeOHYlOj/IIKMmHsoLo3+axxx6T33//Pc2Wl4iIiMgR3g5NTURERERERGSATuj69esnU6dOVQF0lA5s1qyZ6nvHWjJLdHS06q8IzyEJJjQ0VCXCoD8lIiIiovSI5VyIiIiI0rH4+HgJCwtTnUF7eHi4enGIKJXgsuzevXtSoEABVZbQmdBKE4FrR5bFcn+DbHEM1iBwXqNGDb2jd+y3ChUqJH369JGBAwcmmB7BdvTNc/ToUfHx8XH485Dz8VhDREQZiSkVzqsYRCciIiJKxy5evKiCUUSUOVy4cEEKFizo1AC6f1BOkdgHdr8ma9ascv/+fbNxgwcPliFDhiSYFsH5gIAAlVHeunVrfXzXrl1VyZalS5cmeA36LMqRI4d6HZ7PnTu3vPTSSzJgwADx8vJy+DNSyvFYQ0REGdEFJ55XsZwLERERUTqGrED1f5tvxMPH39WL4/aKlczv6kXIUP58v4GrFyHDuBceLiWLFdJ/886iMtBjH4hf+W4iXr5JvyAuWu4fmq0uOoODg/XRtrLQb9y4IXFxcZI3b16z8XiMTHNrTp8+LX/99Zd07txZ1UE/efKk9OrVS2JiYlSwntKett1Zfu9ERETuKDw8XN0cduZ5FYPoREREROmY1qweAXQG0VPOK0ugqxchQ2GwzflSrZSGt694eFkPhBuZPP77blPr+0XpENRDnzZtmso8r1atmly6dEmVeGEQ3bXbXWp+70RERO58XsUgOhERERERUUbn4flosGc6B+TKlUsFwq9evWo2Ho/z5ctn9TX58+dXtdCNpVvKli0rV65cUZnzvr52ZMwTERERpSHn9lhDRERERERE6Q8ysewdHICANzLJ165da5Zpjsd16tSx+pp69eqpEi6YTnP8+HEVXGcAnYiIiNIjBtGJiIiIiIgySya6PYOD+vXrJ9OnT5e5c+fKkSNH5K233pKIiAjp1q2ber5Lly7y0Ucf6dPj+Vu3bknfvn1V8HzFihUycuRI6d27t1M/MhEREZGzsJwLERERERFRRmdvlnkyaod27NhRrl+/Lp999pkqyVKlShVZuXKl3tno+fPnxdPzv+A8OvpatWqVvPfee1KpUiUJDQ1VAfUBAwY4/N5EREREaYFBdCIiIiIiogzP3izz5DVWfvvtt9Vgzfr16xOMQ6mXbdu2Jeu9iIiIiNIag+hEREREREQZXSpmohMRERFldAyiExERERERZXT21jtPRk10IiIiooyOQXQiIiIiIqKMjpnoRERERMnGIDoREREREVFGx0x0IiIiomRjEJ2IiIiIiCijYyY6ERFlckN/u+TqRaA0EvngntPnySA6ERERERFRRsdMdCIiIqJkYxCdiIiIiIgoU2Si2xNEZyY6ERERkSUG0YmIiIiIiDI6T49Hgz3TEREREZEZBtGJiIiIiIgyOpZzISIiIko2BtGJiIiIiIgyOnYsSkRERJRsDKITERERERFldMxEJyIiIko2BtGJiIiIiIgyOmaiExERESUbg+hEREREREQZHTPRiYiIiJKNZ0hEaWTjxo1y5MgRVy8GEREREWXmTHR7BiIiIiIywyA6URo4c+aM/PHHHzJr1izZvHmz9O7d29WLRERERESZMRPdnoGIiIiIzLCcC1EqM5lM8uOPP0qfPn3kxIkT8ssvvzg8j5s3b8rXX38tYWFhEhcXJ3ny5JH27dtLzZo1U2WZiYiIiCiDYU10IiIiomRjEJ0olXl4eMigQYPU3wUKFBB/f3+ZO3euQ/MIDAyUXr16Sb58+cTT01OOHTsmI0aMkK+++koF1ImIiIiIEmdvljkz0YmIiIgsMYhOlMqQRT5lyhSVhY4geK1atRyeR5YsWVQAXstsR2A+Pj5erl27xiA6ERERESWNmehEREREycYgOlEqmzBhguTOnVumTZsmN27ckJEjR+rPzZgxQ9VIt2XgwIFSpkwZ/fEHH3wgly5dUiVdKlSoIGXLlk315SciIiKijBJEtyPLnEF0IiIiogQYRCdKRQiaHzlyRPr16yd+fn4SGhoqTz31lKxevVo9//rrr6vBXl9++aXExsbKvn37VDAdpV2IiIiIiJJkb6eh7FiUiIgyqMHPh7p6ESiNhIeHy2gnz5NnSESp6Pbt2+Lj4yPZsmXTxyErPSW8vb2lWrVqcujQIdm0aZMTlpKIiIiIMk05F3sGIiIiIjLDTHSiVJQ9e3aJiYmRu3fv6oF0ZKdrUOIlsUD4xx9/bLNkC0q6XLlyJRWWmoiIiIgyHE+vR4M90xERERGRGQbRiVJRrly5pHTp0vLTTz+psi0IoK9Zs0Z//o033lBDUg4fPqwy0IsXL64eo446MtHbtWuXqstPRERERBkEy7kQERERJRuD6ESprG/fvjJlyhQVRM+fP780btxY1q5d69A8IiMjZd68eXLt2jXx8vJS88F8jZ2OEhERERHZZG+pFpZzISIiIkqAQXSiNMhGHzRokNm4F154waF5PP7442ogIiIiIkoODw8PNdgxYVosDhEREZFbYVs9IiIiIiKiTBJEt2egtDVkyBCpUqWKqxeDiIiIEsEgOhERERERUUbn4cBAbmfUqFFSo0YNCQoKkjx58kjr1q3l2LFjrl4sIiKiDINBdCIiIiIiogyOmegZ24YNG6R3796ybds2Wb16tcTExMjTTz8tERERrl40IiKiDIFBdCIiIiIiogyOQfSUa9SokbzzzjvSv39/yZEjh+TLl0+VYjE6f/68tGrVSrJmzSrBwcHSoUMHuXr1qtk0o0ePlrx586qs8e7du0tkZGSC95oxY4aULVtWsmTJImXKlJHJkycnumwrV66UV199VcqXLy+VK1eWOXPmqGXZtWuX1emjoqIkPDzcbCAiIiLbGEQnIiIisiEz1al9veljsv/r1nJl1ouyZkhzebx4TpvTvlS/uNz58WWzAa+z9HHbSnJ0Ylu5PKuTLBnYRIrnDTJ7PiTQV6a9VU/OT+8g577rIN++XlsC/TJGv/ftq4fKsj61ZctHDWTua9WkfAHzz27L0+XzyK5BjeWrDhUSPNezYTFZ9W5d+XtgA5ncubIUyuFv9nzhHP7qdWvfrycb+teXmV2rSvUiIeLupk6eJKVLFpWQrFmkft1asnPHjkSn/2XRQqlcoYyavnqVirLyj9/NnjeZTDJsyGdSrFB+yR7kLy2aNZWTJ06YTXPr1i159ZXOkidHsOTLFSI9e3SX+/fviztjEN055s6dK4GBgbJ9+3YZM2aMDBs2TGV+Q3x8vAqgY/tBZjjGnz59Wjp27Ki/fsGCBerYMnLkSPnnn38kf/78CQLkP/30k3z22Wfy+eefy5EjR9S0gwYNUu9tr7t376r/Eey3Vf4lW7Zs+lCoUKFkrhEiIqLMgUF0IiIiolQ2adIkKVq0qMoorFWrluxIIgiY1trUKiKfd64mXyzeLw0//V0Onr8tvw54UnIF+9l8zd0H0fJY70X6UPHdxWbP9322nLz5dBnpN2u7NB28Uh5Exap5+vn8d/o5vVc9KVswm7QZvVY6frVO6pbJI+O71xJ391S5PNLvqZIybeNZ6Tz9Hzl+9b5MfKmyZA/wSfR1+bNlkXeblpDd5+4keK5r3cLSqWaojPz9uHSdtUsexsSpefp6/bc+x3eqJN6envLmD3vl5RmP3hfjcgb6irtauGC+DPiwn3zy6WDZumO3VKpUWZ5v2UyuXbtmdfqtW7ZI15dflK7dusu2nXvkuVatpUPb1nLo4EF9mq++HCOTJ06QCZOmysa/t6uA6HMtm5llA3fr0lmOHD4ky/9YLb8sWS6bN2+U3m+9Ie4stYPojuznkCVt+Z54nTuoVKmSDB48WEqVKiVdunSR6tWry9q1a9Vz+P/AgQMyb948qVatmloP33//vQqo79y5U00zfvx4lX2OoXTp0jJixAgpV66c2Xtg/l999ZW88MILUqxYMfX/e++9J999951dy4hg/rvvviv16tWTChUS3pCDjz76SAXateHChQspXjdEREQZGYPoRC5050Gs7LvwQFYevCO/7b0tv+y6pQb8vergXTlw8YHcfRjn6sUkIqIUmD9/vvTr108FRXbv3q2a2TdrZjsI6Aq9nykrc9edlJ82npZjYXflvdnb5UFUnLzcsKTtF5lErt2N1Ifr4eblCN5qXlbGLj0gv+++KIcu3JGeU7dIvpAAaVntUbbjYwWC5anKodJnxjbZdeqmbDt+Xfp/v1Pa1i4q+ULMM6zdzcu1C8niPWGybN8VOXPjgYxccUwiY+KlVZX8Nl/j6SEyok05+W7DWbl052GC51+qWVBmbjonG47fkJPXImTw0iOSO8hXGpXJpZ4P8feRIjkDZPbf59TzF249lG//Oi3+vl5SIk+guKsJ48dJt+49pMur3aRsuXLy7eSp4h8QIHPnzLI6/aSJ38jTzZpLv/c/lDJly8rgocOlStXHZerkiXoW+qQJ42XAx5/Kc8+3koqVKsmM2d/L5bAw+W3pEjXN0SNH5M9VK2XydzOkZq1aUu+JJ2Tc+G9l4fz/SVhYmLitVOxYNDn7OZQ6uXz5sj6cO3dO3CWIboRMcu1zImscGd3GrG4EyENCQtRz2jQIrhvVqVNH/xs1zE+dOqWC7CgJow0ItmO8PVAb/eDBg/K///3P5jR+fn7qOzAOREREZBuD6ERpJC7eJP+cjZCp66/JgEUXpOPUk9J5+mn5+NeL8u3aazJt43WZ8/cNNeDvCWuvysBfLspL005Jp+9Oyke/XJBpG67JnvMRal5EROQedWrHjRsnPXr0kG7duqlgytSpUyUgIEBmzbIeBExrPl6eUqVYDtlw6LI+zmQS9bhmyUcBWmsCs3jLgfGt5eA3bWTeew2lTGg2/bkiubOqQPiGg1f0ceEPY2TXqRtSs1Ru9bhmydxyJyJK9p65pU+z/uAViTeZpHoi75veeXt6SJn8WWXHmdv6OBy1d5y5JRUL2g5S9WhQVG5HRMvSvf99D5rQkCySK8hPthvmeT8qTg5euieVQh/N887DGDl7I0KerZRPsvh4ipeHh7R9vIDcvB8tRy7fE3cUHR0te3bvkiebNNXHeXp6ypNPNpUd27Zafc32bVul8ZP/TQ9PPd1MjYezZ87IlStX1Dw0KGVRo2YtfRr8j6BnterV9WmwDHjvnTu2i7tKzUz05Ozn8D7YV2sD9r3uwMfHJ8HnQOa3s2hlg6ZPny579+7VBwTF0WloUt5++21Zvny5rFu3TgoWLOi05SIiIsrsMkbRSaJ0CtlOx65Gyvqj92T9sXC5FxkvaHUdZ+U8GwELW6FxvG7/xYdyKOyhLN17R7L5e0njMkHSuEywlMjtx9qVRET/1qlFJiTq1G7dulV1sIam7E899ZRepxYBdDSrj42NVZl6qFO7fv16szq1KEnwxBNPyA8//CATJkyQ4sWLJ6hTO3HiRKlatars2bNHBY5QDqJr165Wg4Do1A3N5jUIxDVt2lQto63O3jBoUruzt5xBfuLt5amyyY3wuFT+/wLjRicuh8vb07fKofN3JDjAR/q0KCerBjeTOgOXS9itB5I35FFZhmsW2el4nCfbo+fyhGSR6+H/fU7ATeLb96P1adxRSICPKqmC4LXRzYgYKZrLekZ4lULZVJb6S9P+sfp8zqyPyrHcijCfJx5rz8FbP+5TNdE3DWigbkbcjoiRPj/vk3uRseKObty4IXFxcZInj3lwNU/evHLs2FGrr7l65Yp63mz6PHnl6tVHN3QQQNfmYTlPbRr8nztPHrPnvb291Q06zN9d4XTRrnNGD+v7HmQuY3DGfk4LFhcpUkTtnx9//HFV9xudYroz3GBFWRQMWjb64cOH5c6dO3rJFkyD4xRKwWiMwXHcTChQoICqpd65c2eHrjv69OkjixcvVsc1lIEhIiIi52EQnSgV4CR288n7MmfzDbkSHiNeHiJx/0bIrQXQ7aW9FiVeftt7R5bsuSOh2X3ktSdyS61igQymE1GmptWpBdSqRaAb9WkRRNfq1J45c0YPbKBOLQI2qFNbo0YNszq1gKbza9asMctGN9apBQQpECBBnVprQXQtCGiZYYnHR48etdnZ29ChQyU923nyhho0209clx1jnpduT5aSzxftc+myuZsAXy8Z1qqsjFh+TGWTp8SAZ0rJrYgYeX3OHomKjZPWVQvI1x0rSpeZu+SGRVCfMh8P/LPrXPHRNJYdTWL/Z9nCJ7n7OdQCR5Y69tuox/3ll19K3bp15dChQ26dPY0bBxUrVlTBbxxTcMO2V69e0rBhQ1U7Hfr27atu8uIxbvTi5iw+t/GGLY4BaF2FVhLNmzdXN1bRCent27fVzWJrcGMYtdiXLl2qWlNpN4wwD39/9y6RRURElB4wiE7kZCevRaqSLUcuR+olJbUAujNpFV3C7sTI8GVhUqmgv7zZMI8UzWW7EzgioowsJXVqEUTH/z179kxQpxZN4i3r1CL7XIMgCYIUzoJsTmOQBNmglsEsZ7p5L0pi4+ITZH/j8bW7CWtzWxMbZ5L9Z29JsbxB6vHVO49uPOQJziJXDfW98fjA+UclSa7diZTcFh2Xenl6SPasvgmy4t3JnQcxEhsfb5YhDjkDfeTGffPMeyiY3V9Cs/vL150q6uM8/w10bv+kobSdvF3Pas8R6GsWDMfj41celWqpUTS71C+VSxqP3SQR0Y/6Uxn9x3GpVayWKvEyZ8t5cTe5cuUSLy8vuXbNvOzStatXVfkPa/Lmy6eeN5v+2lXJm/fR9NrrMA32EcZ5Vqpc5dE88uaT6xa1vPE7v3Xrlpq/u7K7VMu/0yCb2lgn21oWenJh32qsA44AOjK0cUNy+PDh4q6wfhHERkZ4gwYNVEY+guDffvutPg1aQOFYgvJjuEnbtm1beeutt2TVqlX6NK+//roqhzN27Fj58MMPVWsnBOfRWagtU6ZM0cubGc2ePVsF7YmIiChlGEQncpLwh3Eya/N1WX04XHUOBmlRuRxlYODgpYfy9k/n5JmK2eTVerkk0M8rDd6diChz1qm17BQOgb7EgoCWtdevJhIEtFUyIbXExMWruuQNy+eTFbsu6jG0BuXzyfTVx+2aB4K+5QqFyOp9jzpdPHf9vly581DNUwuaB/n7SLUSuWTm2kfz3HHyuoQE+knlojlk39lHddEblMun5vWPIcvd3cTGm+To5fsqqL3+2KPPgdOCGsWyy4KdlxJMf/bGA+kwdYfZuF6Ni0mAr7d8ueqEXLkbpeZ5416U1CyWXY5ffbQdBvp6SYXQIFm069E8UQcdLLtNwS/AXVuq+fr6StXHq8m6v9bK861aq3H4Ta9bt1Z69nrb6mtq1a4j69etlT59/ws2rl2zWo2HosWKqd8e5lG5ShX9RhVqnfd48y19Hii/sXvXLnm8WjU1bv26v9R7o3a627K309B/p7G3s8nk7Oes7b9RIuvkyZOSnmnlv4yWLHnUIa2mcOHCKpCemI8//lgNRl988YXZ45deekkNjrSEJSIiotTDjkWJnOD09SjpM++crD3yqHakK/r9xHvibVcevKuW5fythNluRESZlbFOrcZWnVojW3VqS5YsaTbYqj2LIGC1atVUORkNAnF4bMzCdLVJfxyRLo1KyYv1i8tjBYJlXLdaEujnLT9tOKWen/pmXfmsw6OAI/RvXVEaV8ivOhBFEHxar3pSKFegfL/uvwDYlJVH5IPWFeSZxwtKuYIhah5X7jyQFbsefQfHw8Jl9b5LMuH12vJ48ZxSq1RuGdu1hvyy7awKwLuzH7ddkDaP51cZ4EVzBchHLR4Tfx8v+W3fo05Dh7YqK28/+ah0Q3RcvJy6HmE2oIb5g+hY9TcC6DBvx0Xp/kQRafBYTimZJ1CGtS4r1+9Fy/qjjwL1By6i75UYGdqqjJTKGyiFc/hL3yYlVKekm934psQ77/aT2TOny4/fz5WjR47IO73fkgcREdKlazf1fPdXu8igT/6rxd377b7y56qVMv7rr+TY0aMyYtgQ2b3rHz3ojhsKvd95V74YOUKWL/tNDh44IN27dZH8BQrogfoyZcvK082aS++ePWTnjh2y5e+/5b2+b0v7jp3UPsBt2dupqIM3XZyxn0M5GJTcMrYOICIiIkpPmIlOlELbTt+X0b9fVp2huSJ4bgnLcP1erPT9+bwMeraAPF7EeidmRESZiSvr1GI86qVjvjVr1lTvj9Iw3bo9CgKmB4u3n5NcwX7ycdtKkiebvxw4d1vajvlLrv/bMWjBXIGqo0pNSKCvTHi9lpr2TkS07D17S5oNXSXHwu7q03yz/LAKxI9/rZZkC/CVbcevqXlGxfzXOqDH5L9V4HzpR03V/JftPC8DvrfeuaY7WX34mmQP8JGeDYupsi7IHu8zb7+qVw75gv0czhqdu+W8CsR/0rK0BGXxlr3ncdN8nwrCA+qpvz1vv/RuXFymvlxVvL085PT1COk3/4CcuBoh7qp9h45y4/p1GTb0M9WpJ0quLF2+Uq+/feHCeVUyQ1Onbl2Z88M8GTr4Uxn86cdSslQpWfDLEilfoYI+zfsf9FeB+LffekPdSKtb7wn5bflKyZLlv5JGs7//SQXOWzRroubfuk1b+Wr8BHFn9pZzSU7LhaT2c+hEMzQ0VPX5AMOGDZPatWurm5D4DlC25Ny5c6qMCREREVF65GFiuy+iZFt96K58s+ZR01VTemyx6yHyYfP80uCxRzVqiYgyKtSArVKligrcaFq3bq1qns+ZM0c9Pn/+vKpTi+xIY51aY2d4I0eOlK+//lqvU4vnUKd27969+jTouA0BH2SyG+vUtmnTxubyoZNTvAYdvWE5J0yYkKAkjC0oNYGgfXCHaeLhw87hUqpE6VBXL0KG8vdHjV29CBkGfut5c2ZTHW3aU0bFkfliH5Kz82zx9A1Icvr46Ady86duDi9HYvs57KOLFi2q74/fe+89+fXXX9W02bNnV5ns6MwZJV3INbTtxNnb3+XJA8Qd5e9lXl6H0r+UbGv8vokynvBUOK4xiE6UTNtP35dhyx7Vfk3PEEwf0aagVCmc9EUTERGlPwyiOxeD6M7FILobBdFfdiCI/qPjQXRybwyim2NQ1f0wiE5EqX1cY010omS4fCdaxqy8bFffTC7nITLq9zC5ce9RE3IiIiIiynzsqYdub8kXIiIiosyGQXQiB0XGxMvw5WESE2tKdyVcrEFbk4fR8TJiRZjExLnDEhMRERGRszGITkRERJR8DKITOWjK+mty/la0uFM8Gst68mqUzNx03dWLQkREREQuwCA6ERERUfIxiE7kgFPXImXN4XCV3e1usMjL9t2Ri7ejXb0oRERERJTGGEQnIiIiSj4G0Ykc8POOW+LpxtcVXh4iC3bedPViEBEREVFa83BgICIiIiIzDKIT2en8zSjZeuq+xLthFrqxrMu6o/fkajg7GSUiIiLKTJiJTkRERJR8DKIT2Wn+zlsqkzsjWPTPLVcvAhERERGlIQbRiYiIiJLPOwWvJco0YuJMsvnEvVTpTLRVlRApV8BfSubJIvmy+ejjv/7ziqw5Eu7090Mm/bqj4fJW4zziyYskIiIiokzB3gA5g+hERERECTGITmRnh6Kx8akz75dq55Ssfl6Slh7GmOT8zWgpmssvTd+XiIiIiFzE3nrnjKETERERJcAgOpEdDoU9FCTlmFIhE/3sjSgJuxMjJ65GqoB69oC0+VkeufyQQXQiIiKiTIKZ6ERERETJxyA6kR0OI4guIqnRp+iARRf1v9tVzyFpwdPj0Y2BZyqGpMn7EREREZFrMYhORERElHwMohPZ4eiVSFVLPKPAZzkS9tDVi0FEREREacRD7Ayis54LERERUQIMohPZ4WF0KhVEd6EH0RnorgARERERJYqZ6ERERETJxyA6kR1i4jJewDk6LuPdGCAiIiIiG9ixKBEREVGyMYhOZGcN8YxUzgW88KGIiIiIKFNgJjq5Qv5eX7h6ESiT4LZGRKmNQXQiO/h4eUpsfMbK3Pb14gUSERERUWbBIDoRERFR8nmm4LVEmUbuoIx3vyl3kI+rF4GIiIiI0ghi4/YORERERGQu40UGiVJBxYL+culOtKRGGfGqhQPEz/vR1Yr2P5TI4yf3owLV34fDHkp4pPPeHEno+ExERERElDk8CpDbk4meJotDRERE5FYYRCeyQ7n8/rJi/91UmXefJnklb3DCrPDnq2RXAwxcdEEOXHrotPdEP6nlCzCITkRERJRp2JtlziA6ERERUQIMohPZoVwGDDiXzZ/xPhMRERERWcea6ERERETJxyA6kR3yBPuouujX78U6fd6vzT4jaQmXRQVz+Eqwv1eavi8RERERuY699c4ZQyciIiJKiB2LEtmpbbVHpVXcnUlE2mWQz0JERERE9vH09LB7ICIiIiJzDKIT2enp8tkkKIv7/2RyZfWWRqWDXb0YREREROSCTHR7BiIiIiIy5/4RQaI04uftKe2r53D7vpY61sgh3l7u/imIiIiIKDk10e0ZiIiIiMgcg+hEDnimYogE+Hm6ZSAd10MhAV7StByz0ImIiIgyG2aiExERESUfg+hEDgjw9ZQPmuVTdcXd0YBn8ouvN3/2RERERJkNM9GJiIiIko/RNCIH1SyWVV6smUPcTbd6uaRSwQBXLwYRERERuQCD6ERERETJxyA6UTK8WCunVCkcIJ5ucI2BZaxTPFBeeDy7qxeFiIiIiFzE08NDPD3tGBhEJyIiIkqAQXSiZPDy9JABzfNLnmAf8UjHxV2wbKHZfaXf0/mYVURERESUibEmOhEREVHyMYhOlExBWTyl0KVFcvfiUYmPj5P0xhQfJ7fO7pMSN5eLvy9/6kRERESZGcu5EBERESWfdwpeS5RpRUdHy5tvvilz5swRL79AqdrlK8lTrlG6St25sn+17PtpgGyNiZRzJ4/K+PHjxdubP3kiIiKizMjeLPN0dDpLRERElG4wPZXIQbdv35bmzZurADrERUXIC8Vvqzrp4Mo66XhvXPh0rZtTWha6IfExkWr8pEmT5Pnnn5d79+65buGIiIiIKMNmouN8s2jRopIlSxapVauW7Nixw67X/e9//1Pv2bp162S9LxEREVFaYBCdyAGnT5+WunXryrp169RjPz8/mT9/vnw0cKC8XCeXfPtSESmb3189l5axdC1wX7lQgEx+uYh0qJFThg8bpgL9Pj4+6rk//vhDnnjiCbl48WIaLhkRERERZfSa6Dgf7tevnwwePFh2794tlStXlmbNmsm1a9cSfd3Zs2flgw8+kPr16yf/gxERERGlAQbRiey0detWqV27thw9elQ9zp07twqmd+jQQZ+meG4/+aJdQfmkZX7JFeStAumpGUzXLnLyBvvIkOcLyIg2BaVwDj/9+a5du8qff/4pISEh6vH+/ftVZhAuboiIiIgo80jNTPRx48ZJjx49pFu3blKuXDmZOnWqBAQEyKxZs2y+Ji4uTjp37ixDhw6V4sWLp/DTEREREaUuBtGJ7LBgwQJp3LixXL9+XT0uU6aMbNu2TerUqZNgWlx41C0ZJNO7FJW3GueRUnn9nF7mRbu2KZMvi7zTJK9MfaWo1CiW1eq0jRo1UjcAtIuTsLAwadCggSxbtsx5C0RERERE6Zu9Wej/nmeGh4ebDVFRUTb7Ctq1a5c0bdpUH+fp6ake4xzUlmHDhkmePHmke/fuzv+sRERERE7GXgaJEmEymWT06NHy8ccf6+MQTP/ll18ke/bsib7Wx9tTWlYKUcPlu9Gy4dg9WXM4XC7fjTELqsebEl8Gy+kKZfeVJuWCpeFjQZIn+FGplqRoQf9WrVqpi5mIiAhVd/Lrr7+Wd955x655EBGRaxUrmV+8sgS6ejHc3mNFHrXOIueoN+pRiTtKubjIiFSdv71Z5to0hQoVMhuPUi1DhgxJMP2NGzdUVnnevHnNxuOx1oLT0ubNm2XmzJmyd+9eBz8FERERkWswiE5kQ0xMjPTs2dOsGSqaqKJ5qq+vr0Pzyp/NVzrVzCkda+SQa/di5dyNKDl7M1rO3YyS09ej5MrdGImJM4nJEDj39vKQ/Nl8pERuPymSE4Ov+t/ewLkllJ/566+/5NVXX1V1K+Pj46Vv375y4sQJFUz39ubugIiIiCijsrfeuTbNhQsXJDg4WB+PvoCcAR3dv/LKKzJ9+nTJlSuXU+ZJRERElNoYNSOy4s6dO9KuXTtZu3atPu7zzz+Xjz76KFl1IjV4LeqXY6hppfRj3L/p5l7OrP1ikCVLFpk3b56ULFlSfR6YOHGinDlzRv73v/9J1qzWS8IQERERkXtzNBMdAXRjEN0WBMK9vLzk6tWrZuPxOF++fAmmP3XqlOpQ9LnnntPHIbkDkNRx7NgxKVGihF2fiYiIiCitsCY6kQUElOvWrasH0JF1gwAzSrqkJIBuDwTPUyuAbqxROWLECJVhr2Wfr1ixQurXry+XLl1K1fcmIiIiItewpx66vdnqRmihWa1aNbPkEwTF8dha/0EoM3jgwAFVykUbnn/+eVUyEX9blpEhIiIiSg+YiU5ksH37dnUSf+3aNT2zZunSpSqontGgNE2RIkWkbdu2KvMeFy21atWS5cuXS5UqVVy9eERERETkwkx0R/Tr10+6du0q1atXl5o1a8r48eNVHzw434QuXbpIaGiojBo1SrWMrFChgtnrQ0Ie9VVgOZ6IiIgovWAmOtG/Fi1aJI0aNdID6KVLl1adcWbEALrmySeflC1btkixYsXUY2SiP/HEEyqQTkREREQZL4huz+Cojh07ypdffimfffaZSsZAcsbKlSv1zkbPnz8vly9fToVPRURERJQ2GESnTM9kMsmYMWOkffv2EhkZqcYhmL5169ZMUY+xbNmy6mZB7dq11WNkDbVq1UrVSiciIiKijCG1yrlo3n77bTl37pxERUWp1p1o4ahZv369zJkzx+Zr8dySJUuS98ZEREREaYBBdMrUYmJi5I033pABAwbo49AUddWqVZI9e3bJLPLkySN//fWXupGg1bHs06eP9O3bV+Li4ly9eERERESUjjPRiYiIiDI6BtEp07p79660aNFCZsyYoY8bPny4zJ49W3WQlNn4+/urDlQ/+ugjfdyECROkTZs2cv/+fZcuGxERERGl70x0IiIiooyMQXTKlM6ePatqna9Zs0Y9RtB83rx58umnn2bq7BtPT08ZOXKkzJw5U7y9H/U7vGzZMmnQoIGEhYW5evGIiIiIKJmYiU5ERESUfAyiU6azY8cOVf/78OHD6nHOnDll7dq18uKLL7p60dKN1157TXUGlS1bNvV4z549qq7lvn37XL1oRERERJQMCI3blYnu6gUlIiIiSocYRKdM5ZdfflGdhl69elU9LlWqlOpU84knnnD1oqU7TZo0kS1btkjRokXV44sXL6r19Pvvv7t60YiIiIjIQZ4eHnYPRERERGSOQXTKFEwmk4wdO1Z1nPnw4UM1DiVKtm7dKiVLlnT14qVb5cqVUzcZkIUOqI3+3HPPyeTJk129aERERETkANZEJyIiIko+BtEpw4uJiZGePXtK//79VTAdXnnlFfnzzz9VKRdKXN68eWXdunXSrl079Tg+Pl569+4t/fr1k7i4OFcvHhERERHZgTXRiYiIiJKPQXTK0O7evSvPPvusTJs2TR83dOhQmTt3rvj5+bl02dyJv7+/zJ8/XwYMGKCP+/rrr6Vt27YSERHh0mUjIiIioqR5etg/EBEREZE5BtEpwzp37pyq4Y2Mc/D19ZUff/xRPvvsM2bYJIOnp6eMHj1a3ZDw8vJS45YuXSoNGzaUsLAwVy8eERERESVGlWqxIwudp8lERERECXgnHEXk/nbu3Klqd2sdiObIkUOWLFki9evXd/Wiub0ePXqozkZR3iU8PFx27doltWvXluXLl0ulSpVcvXhEREREZIW99c6Za0JEmc3Q3y65ehEojQx+PtTVi0BujJnolOEsXrxYZUdrAXR0HIrOMRlAd56nnnpKtmzZIkWKFFGPL1y4oLL+V65c6epFIyIiIiIrPBz4R0RERETmGESnDAOdhn711VeqTvfDhw/VOAR2EUAvVaqUqxcvwylfvrxatzVq1FCP7927p+rPT5kyxdWLRkREREQWWBOdiIiIKPkYRKcMITY2Vnr16iUffPCBCqZD586dZc2aNZIzZ05XL16GlS9fPlm/fr288MIL6nFcXJz6Ht5//331NxERERGlD/bUQ9frohMRERGRGQbRye2hLjfqn0+dOlUfN3jwYPnhhx/Ez8/PpcuWGQQEBMjChQvlww8/1MeNGzdO1UyPiIhw6bIRERERkXlNdHsGIiIiIjLHIDq5Ncta3D4+PvL999/LkCFDmEWThjw9PWXMmDHqRoaXl5cah45cGzVqJFeuXHH14hERERFlep4eHnYPRERERGSOQXRyW7t27ZJatWrJgQMH1OPs2bPL6tWr5ZVXXnH1omVab775pqxYsUKCgoLU43/++Ud9RwcPHnT1ohERERFlasxEJyIiIko+BtHJLS1dulQaNGggly9fVo9LlCghW7dulYYNG7p60TK9Zs2ayd9//y2FCxdWj8+fPy9169aVVatWuXrRiIiIiDIt1kQnIiIiSj4G0cmtoNPQ8ePHS5s2beTBgwdqXL169WTbtm1SunRpVy8e/atixYrqO6levbp6fO/ePWnZsqVMmzbN1YtGRERElCkxE52IiIgo+RhEJ7cRGxsrffr0kffee08F0+HFF1+UNWvWSK5cuVy9eGQhf/78sn79emndurV6HBcXp8q99O/fX+Lj4129eERERESZCmuiExERESUfg+jkFpDJ/Pzzz8ukSZP0cYMGDZKffvpJsmTJ4tJlI9sCAwNl0aJF8v777+vjxo4dK+3bt9dbEhARERFR6vNwYCAiIiIicwyiU7p38eJFeeKJJ+SPP/5Qj318fGTu3LkybNgw1mx0A15eXvLll1/KlClT1N/w66+/SqNGjeTKlSuuXjwiIiKiTIE10YmIiIiSj0F0Std2794ttWrVkv3796vHISEh8ueff0qXLl1cvWjkoJ49e8ry5cslKChIPd65c6fUrl1bDh065OpFIyIiIsrwPD3sH4iIiIjIHIPolG4tW7ZM6tevL2FhYepx8eLFZevWrSqDmdxT8+bNZfPmzVKwYEH1+Ny5c1K3bl1ZvXq1qxeNiIiIKENjJjoRERFR8jGITunShAkTpFWrVnrdbARat23bJmXKlHH1olEKVapUSbZv3y6PP/64ehweHi7PPPOMTJ8+3dWLRkRERJShIT6e1EBERERECTGITulKbGys9OnTR/r27Ssmk0mN69ixo6xdu1Zy587t6sUjJylQoIBs3LhR3SiBuLg4eeONN2TgwIESHx/v6sUjIiIiynCYiU5ERESUfN4peC2RU92/f186deokK1as0Md98sknqgNRT0/e78loAgMD5ZdffpEPP/xQvv76azXuiy++kFOnTsn3338v/v7+rl5EIiIiogzD3nrnrIlORJnN4OdDXb0IROQGGJmkdOHixYuq/rkWQPf29pZZs2bJiBEjGEDPwLy8vGTcuHEyceJE/XtetGiRNG7cWK5everqxSMiIiLKMJiJTkRERJR8jE6Sy+3Zs0dq1aole/fuVY9DQkJk1apV0q1bN1cvGqWR3r17q45ks2bNqh6jZnrt2rXl8OHDrl40IiIiogzBw4GBiIiIiMwxiE4utXz5cpWBHhYWph4XK1ZMtmzZIk8++aSrF43SWIsWLWTz5s0SGvqoKd3Zs2dVh7Koh09EREREKePp4WH3QERERETmWBOdXAYlPNCBqNaRJDKPly5dKnny5HH1opGLVK5cWWWhP/fcc6qFwt27d6V58+by3XffyWuvvebqxSMiytDaVw+VLnUKSc6svnLiaoSMWXlcDoXdS/J1T5fPI6NeKC/rj12X9xccNHuuZ8Ni0qZqfsmaxVv2Xbgro/44LhduPdSfL5zDX/o2LSFVCmUTby9POXn1vkxZf0b+OXdH3N1TpXPJc+XzSDZ/Hzl/66HM2XFRTt18YHXaGoWzSesK+SRvsK94eXjIlXtRsuLwNdl8+rY+TdvK+aRO0eySM8BHYuNNcubWQ5m/J0xO3fhvnh80Li5FcvhLcBZviYiKk4OX78nPuy/J7Yex4s64bToHYuP2xMcZQyciIiJKiJnolObi4uJU8LxPnz56AL1Dhw7y119/MYBOKhN948aNKpAOsbGx0r17d/n444/17YWIKK0MGTJEqlSpIhndU+XySL+nSsq0jWel8/R/5PjV+zLxpcqSPcAn0dflz5ZF3m1aQnZbCSx2rVtYOtUMlZG/H5eus3bJw5g4NU9fr/9OP8d3qiTenp7y5g975eUZj94X43IG+oo7q100RF6pHiq/7LsiHy8/JuduP5SBTUuo4LY196PiZPGBK/LZH8dlwLKjsuHkLelZt4hUKhCkT3M5PEoF4vH80JUn5Pr9KPm4aUkJ8vtvnoeu3JNvNpyR95cclq83nJG8Qb7ybsNi4s64bToPa6KnX5nlWENEROTOGESnNHX//n1p06aNTJgwQR/30Ucfyc8//yz+/v4uXTZKP1AbffHixepmi2bUqFHSqVMnefjwvywxIiJ3oN0YLFCggApOLVmyRNKbl2sXksV7wmTZvity5sYDGbnimETGxEurKvltvsbTQ2REm3Ly3YazculOwn3zSzULysxN52TD8Rty8lqEDF56RHIH+UqjMrnU8yH+PlIkZ4DM/vuceh5ZwN/+dVr8fb2kRJ5AcWcty+aRv07clA2nbsmlu5Eyc9sFiY6Ll0Ylc1qd/sjV+/LPhbsSdjdKrt2PlpVHr8v52w+ldJ5HfYXAljO3VWY5nr94N1J+/OeSBPh6SeHsWfRp/jhyXU7eeCA3ImLkxPUI+e3gVSmZO1C83Dgmym3Tebw8PewekmPSpElStGhRyZIli+rvaMeOHTan/fXXX6V69eqqL6TAwEAVQP7hhx9S8OnIHY41RERE7oxBdEozqHveoEED1YEkeHt7y8yZM2XkyJHi6clNkcx5eXnJ+PHj1Q0XbftYuHChqpd/7do1Vy8eEZHdIiIiVLkqBJjSI29PDymTP6vsOPNf6RCTiOw4c0sqFgy2+boeDYrK7YhoWbr3coLnQkOySK4gP9lumCeyrQ9euieVQh/N887DGDl7I0KerZRPsvh4qjImbR8vIDfvR8uRy0mX6kivEIAsljNABbyN6xOPS+UOsGse5fNllfzBfnL06n2b7/FkqVwSER2rgu3WBPp6Sb3iOeT49QiJwwK4IW6bqVPOxZ7BUfPnz5d+/frJ4MGDZffu3Wqf16xZM5vnbDly5JBPPvlEtm7dKvv375du3bqpYdWqVSn/oJlUej/WEBERuTtGLilN7Nu3T2WkoM41ZMuWTVauXMk615QklP1BrXxkKcG2bdtU/fwjR464etGIKB1p1KiRvPPOO9K/f38VnMmXL59qHm90/vx5adWqlWrtEhwcrEqJXb161Wya0aNHS968eSUoKEiVkoqMjEzwXjNmzJCyZcuqbMsyZcrI5MmTE122Z555RkaMGKFaYtkjKipKwsPDzYbUFBLgo8pWIEBodDMiRnJl9bP6GtSJRibwiOXHrD6P2tVwK8J8nnisPQdv/bhPSufLKpsGNJAtHzeQzrULSZ+f98m9SPet4R3s56WC3HcfxpiNv/swVkKy2C5B4u/jKbNfrCQ/vFxF+jcpIXN3XpQDFgHbqqHBaprvO1eWFuVyy8jVp+ReVJzZNC8+XkBNM+Pf0iNfrTst7orbpmvLuVjuh7BvsmXcuHHSo0cPFQgvV66cTJ06VQICAmTWrFk299nYJ2JfWqJECdX6sFKlSqqT+fSMxxoiIqLMi0F0SnW///67PPHEE3Lx4kX1GM08t2zZIk2aNHH1opGbePbZZ2XTpk2qeSqcOXNG6tSpo+roExFp5s6dq264oYPiMWPGyLBhw2T16tXqOfSpgKDGrVu3ZMOGDWr86dOnpWPHjvrrFyxYoIIhaCH1zz//SP78+RMELX766Sf57LPP5PPPP1c38zDtoEGD1Hs7C8pX4WazNhQqVEjSE5QQGdaqrApSImM3JQY8U0puRcTI63P2SNeZu2T9sRvydceKkssQzMwsUKJk4PKj8umKY7Jgz2V5uXqolM37XzkXOHz1vppm8B/HZd+le9K3QdEEddaXH7oqHy0/JiNXn5R4k0l61SsimQW3zaQv/OwdAPse474I+yZroqOjZdeuXdK0adP/3svTUz1GpnlSTCaTrF27Vo4dO6ZaraZ3PNYQERFlTtZ7NyJyEpwQGjsQRTY6soqReUHkiKpVq6qLFdR63Lt3r9y9e1c1E542bZrKeiIiQhYjSglAqVKlZOLEiSow89RTT6n/Dxw4oG7CaYGC77//XsqXLy87d+6UGjVqqBJSyAjEAMjoW7NmjVmGIOb/1VdfyQsvvKAeFytWTA4fPizfffeddO3a1SmfA32FoCyCBtmBqRncuPMgRmLj482ycCFnoI/cuJ8w87Rgdn8Jze4vX3eqqI/z/DdzdfsnDaXt5O165nCOQF+5YcgixuPjVx5lV9coml3ql8oljcdukojoR9nUo/84LrWK1VJlNOZsOS/uKDwqTuLiTZLN3zzrPJu/t9yJtB3YRZmSq/cerSt0RFogm5+0qphX1UvXRMXGq2kwnLxxXsa1LiuNS+aUpQf/y3JFZjqGK/eiVD32Se0qSKlcAXLixgNxN9w2ncveTkO1aS5cuKAyqTV+ftaz/2/cuCFxcXEJzu/x+OjRozbfB+dy6FAeGdEo44frBuyv0zsea4iIiDInBtEpVeBE+sMPP5Svv/5aH9euXTt1EskORCm5ChYsqDpNevHFF2XFihUSGxurSgKdOnVKZQGxtj5R5obAhhGy+7R6vMjkQ3DAGCBAyQF0aofnENjA/z179jSbB1q9rFu3Tq83i/0NAh8oW6DBvghZfM6CQJWtYFVqiI03ydHL91XgENm2gBBajWLZZcHOSwmmP3vjgXSYat5hYK/GxSTA11u+XHVCrtyNUvO8cS9KahbLLsf/DQKjRneF0CBZtOvRPFFrGuIt6nXjtrs9gb70CgH0MzcfSIX8QaqzUMCnKZ8vSP78d/3aA8FfnyQ6eMQ03on0GqqtRm8v9zw+ctt0Liy6PX2Gah8RAXRjEN3ZUMoEiRH3799XwWcEdIsXL65KpqRnPNYQERFlTgyik9PhxO+ll16S3377TR83YMAAdiBKTrvgWrJkibz33nsq8wfQ1PXkyZMyZ84cVTeSiDInHx/zzF8Eu7SWUM6AQA9Mnz5dtawyQhalO/tx2wUZ2qqM6jTxYFi4vFSzoPj7eMlv+x51zDi0VVm5fi9KJv51WqLj4uXU9Qiz12t1oo3j5+24KN2fKCLnbz2QsDuR8lajYnL9XrSsP/ooGHrgYrjci4xR7zt901mJiomXNlULqI4fN5+0P9icHq04ck3eqldETt94ICdvRsgzZfOIn7enbDh5Uz2P524/iJb/7Xm0fltVyCunbz6Qq/eiVFC8amg2eaJ4Dpm17YJ6Hq9tXTGv7LpwV5UpCfLzlqfL5JbsAT6y/ewdNU2JXAFSImeAHLsWoToczRvkJ+2r5Jcr4VFywuL7cifcNp3H084guj3TGOXKlUvtAy3rfuMxaobbfB9PTylZsqT6u0qVKiq4jBIj6T2IzmMNERFR5sQgOjlVWFiYKrexe/du/URvypQpZlkURCnl7e0t3377rWpC++6776pamvPnz1fNjhFgz507t6sXkYjSGXTOhn0EBi1DEE3j79y5o7IEtWlQNqpLly7669CZsbE0AfpmQH3bzp07S0ay+vA1FZDt2bCYKp2BDN0+8/armtCQL9hP7WsdMXfLeRXs/KRlaQnK4i17z9+VPvP2qUAnIBj89rz90rtxcZn6clUVPD59PUL6zT8gJ666b9AXtp29I8F+3tKuSn4J8feWc7ceyui1p+TuvwHdXIE+ZusTQfJutQpKzgBftX7CUIZl81k1H4iPN0mB4CzSoFEOFUC/HxUnp25GyNCVJ+Ti3UclIKJj46Vm4RD1npgfSqHsCwuXxfvPquxrd8Vt03XlXOzl6+sr1apVU9nkrVu3VuMQVMbjt99+2+754DWJdV7qDnisISIiyrgYRCen2b9/v+oAEieNgOafixYtcovahuSe3nnnHVUjslOnTvLgwQPVYW3t2rVVZ7alS5d29eIRUTqCDu4qVqyoAhKoR4tm8b169ZKGDRtK9erV1TR9+/aVV199VT2uV6+e6tjt0KFDqryAZujQoWrfgyb1zZs3VwEfdAx3+/Zts9qyllmFaC2jQa1clDDIkSOHFC5cWNKLBf9cUoM1b/6wN9HXDvnNet3jqRvOqMEWZBe/PW+fZEQo3WKrfMvwP//bHmDB3stqsCUm3iRfJ7Ie4cKdSBmx2ny+GQW3zfSdiQ7Y/6FWN/afNWvWVPtZtE7V+q1BwBj1z7XOSfE/pi1RooTaj+Lc7YcfflDJN+6MxxoiIqKMi0F0coqVK1dKhw4d5N69Rx0yFSlSRNWsRic6RKkJLR82bdqkbuBcvnxZZe2gruSvv/6a7psDE1HaQWYlOrZGZ9cNGjRQZQQQmECrFk3Hjh1VHdr+/furDt7atm0rb731lqxatUqf5vXXX5eAgAAZO3as6vsjMDBQBUzQKsYWBD4aN26sP9YCIAg4oQwVEVFaQIK5PUnmySn7jv3n9evX5bPPPpMrV66o8iy4PtA6Gz1//rxZWUcE2BFcvnjxouovqUyZMvLjjz+q+bgzHmuIiIgyLg+To+0fiSwgYwQniuhMFNBhDuqhJ1YDkcjZ0AICgXS0iNDqVc6YMcOsqSwRkTsKDw9X2YiVP14mXlkCXb04bu+xIiGuXoQM5fi5RyVnKOXiIiNk38jn5O7du07t0FPbh7y7cJf4BWRNcvqoB/dlfPtqTl8OSt+07YTfOxERZQThqXBcYy+PlGwImr///vsqi0QLoL/wwguyfv16BtApzaHu5ObNm6VFixbqcUxMjMq8QUYU7xUSERFRZufpwEBERERE5niORMmCJpjt2rWTcePG6ePQ1HDhwoWq6SGRKwQFBakmtLixoxk+fLi8/PLLqrksERERUWYv52LPQERERETmWBOdHIY6h6hDjbp74OXlJZMmTZI333zT1YtGJN7e3jJx4kQpVaqUqgWJLPR58+apWpyLFy+WXLlyuXoRiYiIiNKcp3iIpx0RckxHlFYuTx4g6VH+Xl+4ehEonWyH3BaISMNMdHLIwYMHpVatWnoAHZm/6ECUAXRKb506oeMlBM21lhEo9VK7dm05fvy4qxePiIiIKM0xE52IiIgo+RhEJ7uhx/i6deuqjF4oXLiwbNmyRZo1a+bqRSOyqlWrVrJx40a9Rv+pU6dUIB3jiIiIiDITTw/7ByIiIiIyxyA62WXatGnSsmVLuXfvnnpcvXp12bZtm1SoUMHVi0aUqGrVqsn27dulYsWK6vHt27eladOm8sMPP7h60YiIiIjSDDLMUc4lqYGZ6EREREQJMYhOiYqPj1cdhqJcS1xcnBrXunVrWb9+veTPn9/Vi0dkF7SaQDkXrdVETEyMdOnSRYYMGaJqphMRERFldCznQkRERJR8DKKTTQ8ePJD27dvLl19+qY97//33ZdGiRRIYGOjSZSNyVHBwsCxfvlx69uypjxs6dKi88sorEhUV5dJlIyIiIkptLOdCRERElHwMopNVV65ckUaNGsmvv/6qHnt5ecmUKVNUQB1/E7kjb29vmTx5snz11Veq81H46aef5KmnnpKbN2+6evGIiIiIUo2HA/+IiIiIyByD6JTAoUOHVOeLO3fuVI+DgoISZPASuSsEz/v16ye//PKL+Pv7q3GbNm2SOnXqyIkTJ1y9eERERESpgpnoRERERMnHIDqZWb16tdStW1fOnTunHhcqVEjVkm7evLmrF43Iqdq0aSMbNmyQfPnyqccIoOPmEQLqRERERBkNg+hEREREyccgOummT58uzzzzjISHh6vH1apVk+3bt0ulSpVcvWhEqaJGjRqybds2qVChgnp869Ytadq0qSrxQkRERJTRWuPZOxARERGROQbRSeLj42XgwIHyxhtvSFxcnBrXqlUrlaWbP39+Vy8eUaoqUqSIam3x9NNPq8fR0dHy8ssvy7Bhw8RkMrl68YiIiIicgpnoRERERMnHIHom9/DhQ+nYsaN88cUX+rj33ntP1YsODAx06bIRpZVs2bKpuv+4kaQZPHiwdO3aVaKioly6bERERETOgARzewciIiIiMscgeiZ29epVady4sSxatEg99vT0lEmTJsm4cePEy8vL1YtHlKZ8fHxk6tSpMnbsWL0Z8w8//KAy1FHmhYiIiMideXp42D0QERERkTkG0TOpw4cPq04UUfMcsmbNKsuWLZNevXq5etGIXAbB8w8++EDdWPL391fjNm7cKHXq1JGTJ0+6evGIiIiIko3lXIiIiIiSj0H0TGjt2rVSt25dOXv2rHocGhqqakK3aNHC1YtGlC688MILsn79esmTJ496fPz4cXXT6e+//3b1ohERERElj72lXBhEJyIiIkqAQfRMZubMmdK8eXO5e/euely1alWVjV65cmVXLxpRulKzZk312yhXrpx6fPPmTXnyySfl559/dvWiERERETnMUzzsHoiIiIjInLfFY8qg4uPj5ZNPPpHRo0fr45577jmZN2+eKuVCRAkVLVpUZZ+3b99e1qxZI9HR0fLSSy/JqVOn1O9Jq51ORERElN7Z22koT28oLeXv9YWrF4GI2yER2YWZ6JnAw4cPpVOnTmYB9L59+8rixYsZQCdKQkhIiPz+++/y+uuv6+MGDRok3bp1U0F1IiIiInfAmuhEREREyccgegZ37do1VYJi4cKF6rGnp6dMmDBBxo8fL15eXq5ePCK34OPjI9OmTZMvvvgvQ2Hu3LnSrFkzuX37tkuXjYiIiMgenh4edg9EREREZI5B9AzsyJEjqjPEbdu2qceBgYGydOlS6dOnj6sXjcjtoHRL//791Q2pLFmyqHHofLROnTqqvAsRERFRemZPp6L2lnwhIiIiymwYRM+g/vrrLxXcO3PmjHpcoEAB2bRpkzz77LOuXjQit9auXTtZt26d5MmTRz0+duyYulm1ZcsWVy8aERERkU2q01B7MtHZsSgRERFRAgyiZ0CzZ89WZSbu3r2rHlepUkW2b98uVatWdfWiEWUIWguPsmXLqsc3btxQZZPmz5/v6kUjIiIisoqZ6ERERETJxyB6BhIfHy+ffvqpvPbaaxIbG6vGtWzZUjZu3CgFCxZ09eIRZSjFihVT2ecInkNUVJTqwHfkyJFiMplcvXhERERECS787B2IiIiIyBzPkTKIyMhIeemll+Tzzz/Xx6H2+ZIlSyQoKMily0aUUYWEhMgff/yhblxpPvnkE+nevbtER0e7dNmIiIiILPt3sXcgIiIiInMMomcA169flyZNmuilJDw9PeWbb76RCRMmiLe3t6sXjyhD8/X1lRkzZsioUaPMSio1b95cbt++7dJlIyIiItJ4ODAQERERkTkG0d2cZaeGAQEBKvv8nXfecfWiEWUayNgaOHCgupHl5+enxqHz0bp168rp06ddvXhERERE9nUq+u9AREREROYYRHdj69evlzp16uhBuvz588umTZvkueeec/WiEWVKHTp0UMHzXLlyqcdHjx5VN7m2bt3q6kUjIiIiYhY6ERERUTIxiO6m5s6dK08//bReLqJSpUqyfft2efzxx129aESZGm5s4bdYpkwZvdxS48aNZcGCBa5eNCIiIsrEkGBu70BERERE5hhEdzMmk0k+++wzefXVVyUmJkaNa9GihWzevFkKFSrk6sUjIhEpXry4KrGE4DlERUVJx44dZfTo0eo3TERERJTW2LEoERERUfIxiJ4C8SaT3IqIlct3o+X8rSg14G+Mw3POFhkZKS+//LIMHz5cH9erVy9ZunSpBAUFOf39iCj5smfPLitXrlQ3vDQfffSR9OjRQ78B5kzY59y8HyuX70TL+Zvm+yMG7omIiMjTgSE5Jk2aJEWLFpUsWbJIrVq1ZMeOHTannT59utSvX1+dL2Fo2rRpotMTERERuZq3qxfAXUTFxsvhSw/l7M1oOXczSk5fj5ILt6IlOs56cMrXy0MK5fCV4rn9pEhOPymay1fKFfAXP+/knZbeuHFDWrduLX///bd6jAyRcePGSd++fZktQpRO+fr6yqxZs6RUqVLyySefqHEzZ86Us2fPyqJFiyQkJCRZ842MiZdDYQ/VvujcjehH+6Pb0RJja3/k7SFFcvhKMW1/lNNPyhXIIr7J3B8RERGR+7E3yzw51xboXL1fv34ydepUFUAfP368NGvWTI4dOyZ58uSx2rfTiy++qDphR9D9iy++UKUqDx06JKGhoQ6/PxEREVFq8zAxRdGmuHiT7L/wQNYdC5fNJ+5LVKxJ1QhE2MlGrCoBL09kiKIMi0gWbw95olRWaVQmWCoVDBAvT/tOUI8fP65Ktpw6dUo9DggIkHnz5kmrVq1S8vGIKA3973//U1npKO0CZcuWlRUrVkixYsXs3h/tOf9A1h8Nl79P3lc38BzeH3mIxKuyUCJZfDykwWNB0qh0sFQs6C+evBlHlG6Fh4dLtmzZpPLHy8QrS6CrF8ftPVYkeTcwybrj5+64ehEyjLjICNk38jm5e/euBAcHO30fMmfTUQnImnTr1Qf378mr9cvIhQsXzJbDz89PDdYgcF6jRg2ZOHGiehwfH69KTfbp00cGDhyY5HvGxcWpjHS8vkuXLg59PnLuduLs7Y+IiCijHNeYiW7FnQexsuif27LmyF25FxmvAk9akArBpzgH5hWHiNW/ImNNsu7oPVlz5J5k8/eSJmWDpV217JItwPbXsHHjRpWBrnUgmi9fPlm+fLlUq1Yt2Z+PiNJep06dpHDhwurmF1qWHDlyRGrXri2//fabuvC0BeVYFv1zS/46Gp7y/ZEh2B4ZY5K1h8Plz0PhEhLgJU3LBkvbajkk2N8rBZ+SiFLTn+83YGDDCeqNWufqRchQTh275OpFyDBMMQ/TVSa6ZX9LgwcPliFDhiSYPjo6Wnbt2qXK1mk8PT1ViZatW7fatWwPHjxQ5e5y5Mhh1/REREREaY1BdIOY2Hj5bd8d+WnbTVUWARnk4kCWpz20ed19GCdL9tyW3w/ckZdr55JnK4eID6JjBj/88IN0795dr59csWJFFUBHII6I3A+aLG/btk1atmypmjdfu3ZNGjVqJD/++KO0bdvWbNro2HhZsueO/LzjpsSm8v7ozoM4+XU39kd35ZU6OaVFxRDxttgfERERkXvz8vBQgz3TgbVMdGuQHIBM8rx585qNx+OjR4/atWwDBgyQAgUKqMA7ERERUXrEgrgqm9MkW0/dlze+PyuzNt9QZVu0gFVqwnsgG3TGpuvy5vdnZPvp+2pZMCDLA00ZtQB68+bNZfPmzQygE7m5EiVKyJYtW1TwXOswuF27djJmzBj997/5xD3pMfesfL/lhkSn4f7oQXS8fLfhurz1w1n552xE6r8pERERpRkPBwZAAN042Aqip9To0aNV2bvFixer+uhERERE6VGmz0RHh6HfrLkqG47dU/WFXeXavVgZtixMGj4WKPvmfSLzfpyrP9ezZ0/59ttvxds7039dRBkCmiqvWrVK3njjDZk7d66egXX81Dkp9txHsuXUA3UB66oOK66Ex8jgpZfk6fLB0qtRHvFhB6RERERuD9c69lzvOHpNlCtXLvHy8pKrV6+ajcdjlKJMzJdffqmC6GvWrJFKlSo59sZEREREaShTR0Zu3I+R9+efl43H76nHruxiVXvv9cfuybl8rcUvOLeqR/jVV1/J5MmTGUAnymB8fX1l9uzZMnz4cPU4S/YCcjxHS9VpKLiyx2ct8331oXDpv+iC6ieCiIiI3JuneNg9OHpOg/6a1q5dq49Dx6J4XKdOHZuvQys8nAetXLlSqlevnqLPRkRERJTaMm1k9uLtaPnoFwSH4lwaPLfk4eEpQfkfk3r9FskrZe/Jqx1aunqRiCiV4EbZp59+KjkKl5Nfz+cTn4AQtQ9IL7BrPHktSvrNPy+j2haSvME+rl4kIiIiSmeZ6NCvXz/p2rWrCobXrFlTxo8fLxEREdKtWzf1PMpUhoaGyqhRo9TjL774Qj777DOZN2+eFC1aVK5cuaLGZ82aVQ1ERERE6U36idakoavhjzLQEUBPi1rDjvL08hb/kLyy6nZpuRb+qCY6EWVMYXeiZV1EJckSlFP99tMb7COv34tVgfRbEcxIJyIiclceDvxzVMeOHVVpFgTGq1SpInv37lUZ5lpno+fPn5fLly/r00+ZMkWio6NVvzD58+fXB8yDiIiIKD1KfxGbVBYdGy8jloWpDvTSYwBdYxIPuR8VL5+vCJMv2xdiTWKiDCgyJl6GLwtT/+M3n15hXxn+ME4+Xx4mX7QrJN5e6XdZiYiIKO0z0eHtt99WgzXr1683e3z27NnkvQkRERGRi2S6yOyU9dfkzI2odB1A12AZT12Lkmkbr7t6UYjIyUwmk0xce1WVlnKX/dGxK5Ey+2/uj4iIiNyRh5310JOTiU5ERESU0WWqIPqfh+7Kn4fCXdphn6OwrL8fuCt/HQl39aIQkRPhd73u2D23CKBrsKhL9tyRTf92xkxERETul4luz0BEREREmTSIfvdhnExZd03c1cS/rsq9yDhXLwYROQFqi0/b4J77I1xXf7PmijyI4v6IiIjInTCITkRERJR8mSaI/tve2xLrTimfFqLjTLJs3x1XLwYROcGSPbfdKgPdCIsdGWOSFQfuunpRiIiIKJ10LEpERESU0WWKIHpEVJxbB63AZBJZvPu26hCViNwXOuhctveOe++PRGTRP7dUh6hERETkHjw97B+IiIiIKBMG0ZfvuyNRMW4csfrXw+h4+eMAs9GJ3Jm7t4rR3I+KV/1MEBERkXtgJjoRERFR8nlLBmcymWTp3jup2plorWKB8lyVECmZJ4v4eXvI9fuxsv30fVmw85bci3RepiY+w9I9t6VttRxOmycRpZ14k0l+2+f8LPTiuf3kiVJZpXwBf8kT7CPZ/L1U65WwOzGy5dQ91YoFJVicbemeO/J8lexOny8RERE5n731zlkTnYiIiCgTBtGv3I1RnYqmls61c8pLtXKajQsN8ZUXHs8hdUsEyYBFF+TG/Vinvd/NiDi5Fh6jAmVE5F4u3oqWiCjnl0B5pmI2aVExxGpwHUP9UkHywYILTi8HdSU8Rm5HxEr2wAx/KCEiInJ7iI3bk2XOGDoRERFRJizncijsYarNG1mfWgA9Lt4kc/6+LsOXXZIjlx+9Z75sPvJO07xOf9/DqfiZiMg990eotY6+H7APGrL0kmw6fk9/rkhOP2lVJWGQ3RkO/7u/IyIiovSNNdGJiIiIki/Dpw8evhwpXp4Icjt/3q2q/heUWn04XBb+c1v9ffJalMx+rZh4enhItSKBUjiHr5y/Fe2U98RnQdCqUZlgp8yPiNLOEeyPPETinFxZZf3RezJr03V5aCjZ8s/ZCAnN7qsy0aF0fn/nvqm2Pwp7KPVKBjl93kRERORc9tY7Z010IiIiokyYiX7w4oNUCaBDpYIBVrPDUb7l+r3/SrhULvTfdCmFz3LgIjM/idzRAeyPTKmT4W4MoAMehd357+ZdpJNLuWj7o4OXuD8iIiJyp5ro9gxERERElMmC6LcfpE499Kx+nhKUxeu/94kwr3tufIyyLs50+4HzaqwTUdq5k4r9M1gKyuJpdgMPnR2nBst9HxEREaXnmuj2DURERESUycq5xKRG2qeI+PmY33+IjTfZfOxvMW1KRcemzmciotRjMpkkJo1+uwG+njLouVD9Rh9Ku6w/9l+NdGeK4v6IiIjILXiKhyo3ac90RERERJTJgugIXKWGqBjz0gg+KHRs4/FDi2lTiiErIveUFr/dnFm9ZVirUCma61Et9L0XHsjIFWGp9t4W9w+JiIgonbI3y5whdCKRob9dcvUiUBoa/HyoqxeBiNxAhg+i+3p7Smwq1AK+HxUv9yLj9EzP7AHmqzJ74H+Pr9yNcep7+3nz1JbI3Xh4eIivl4dEp1LrGCiS01eGtgqV3EGPSkhtPH5PvvrzisSm4ntyf0REROQmGEUnIiIiSrYMXxMdtctTy/6LD/S/y4f663/nDfaWPP8GsWDfhf+mc4asfv/VYici9xGYivujSgX9ZUz7QnoA/dddt+SLPy6nagAdgv25PyIiInIHHg78IyIiIqJMlomO4PaNY/dSpeTAb3vvSL2SQervJmWD5fLdGDl/M0o61MipT7PnfIScvxXttPf08hSpYAjYE5H7KFfAX7aeuu/0/VGdElllQPN84uP9KEi//li4bD19X8oVyGLWl8LJa1FOfV/sj8oX4P6IiIjILXigZZx90xERERFRJguil8vvL+uOpk6HegcvPZT/7bgpnWrmFC9PD+laN5fZ89fCY+SbNVed+p5x8SJl8zNoReSOEHDecvK+0+dbu3igHkCHRqWD1WB0NTxGXpt9xun7I9wYICIiovSP1VyIiIiIki/jB9FTOcDzw9abcuJqpDxXJbuUzO2n6gNfvx8r209HyIJ/bkn4wzinv6exdAwRudf+KKP1w8kgOhERkZtgFJ2IiIgo2TJ8EL1wTl8J8PWUB6nQuahm2+kINaRVTeXQkP/qrROR+yie2098vT1UaRVn+nr1VTWktZAAL8kTlOEPI0RERBmCvfXOWROdiIiIKBN2LOrp4SHNymcTzwxwLojP8EyFbOJhVzFDIkpvUPbp6XLBGWJ/hN0Q90dERETuA4dsewciIiIiymRBdGjzePYMcTKIABw+CxG5r7bVckhG4OPlIc9X4f6IiIjI3aq52DMQERERUSYMoufM6u322egqC71iNgkJYOkEIneWJ9hHmpR172x0LPtzlUMk2N/L1YtCRERE9mIUnYiIiCjZMkUQHdpVd//sz7bMQifKENpXzyEmk3sH0VtX5f6IiIjIHWui2/OPiIiIiDJpED1vsI+8WDOnuKuXa+eUXEHsUJQoIwjN7qsC6e6qa71ckiOQrWKIiIjcCWuiExERESVfpgmiQ6daOeTxwgFuVUYBy1qjaIC0r+G+ATciSujlOjmlYkF/t9sf1S2RVdowC52IiMjtsJoLERERUfJlqiC6p4eHfNg8v2QP8HaLwBWWEfXcP2ieXy07EWUc6Ch44DP5VV1xd9kfoUXPe0/nEw/uj4iIiNwPo+hEREREyZapguiAgNWg5wqogFB6jgNh+RBkw7Jm9WPnfUQZEToKHvRsgUdNpyV974+8PT3ks+cKSIBvpjtsEBERZQisiU5ERESUfJkyGlIqbxYZ3qag+Hp5pMsMUCyTr7eHfN6moJTIncXVi0NEqahMfn8Z2ipUfNLx/iiLj6eMaldQCuf0c/XiEBERUTKxJjoRERFR8mXanuEqFQyQse0LyWdLLkl4ZJzEmyTdBKyy+XvJsNYFpXhuBqyIMoOqhQPli3aFZPDSi3I/Kj5d7Y9Q/mpEm1AG0CnTGjJkiCxZskT27t0rGd3UyZPk63Fj5eqVK1KxUmUZN/5bqVGzps3pf1m0UIYNGSTnzp6VkiVLyYhRX0jzZ1roz5tMJhk+dLDMnjld7ty5I3Xq1pMJE6dIyVKl9Glu3bol/fr2kd9XLBNPT09p3aatfPn1N5I1a1Zxd+2rh0qXOoUkZ1ZfOXE1QsasPC6Hwu4l+bqny+eRUS+Ul/XHrsv7Cw6aPdezYTFpUzW/ZM3iLfsu3JVRfxyXC7ce6s8XzuEvfZuWkCqFsom3l6ecvHpfpqw/I/+cuyPu7PWmj8k7LctJnmz+cvD8ben//U7Zffqm1Wlfql9cJr9Z12xcZHSc5HvtZ7NxH7etJF0al5JsAT6y/fh16Td7h5y++t/3ExLoK2O61JDmj4eKKV7kt53nZeAP/0hEVKy4K3srtTCGTiQy+PlQVy8CERGlM5kyE11TIk8W+bZzEZWZnl6UyZdFvn2pCAPoRJnMY/jtd370208vF6/lC/irZWIAnShlRo0aJTVq1JCgoCDJkyePtG7dWo4dOybpycIF82XAh/3kk08Hy9Ydu6VSpcryfMtmcu3aNavTb92yRbq+/KJ07dZdtu3cI8+1ai0d2raWQwf/C/p+9eUYmTxxgkyYNFU2/r1dAgMD5bmWzSQyMlKfpluXznLk8CFZ/sdq+WXJctm8eaP0fusNcXdPlcsj/Z4qKdM2npXO0/+R41fvy8SXKkv2AJ9EX5c/WxZ5t2kJ2W0l6N21bmHpVDNURv5+XLrO2iUPY+LUPH29/judH9+pknh7esqbP+yVl2c8el+MyxnoK+6qTa0i8nnnavLF4v3S8NPfVRD91wFPSq5g28emuw+i5bHei/Sh4ruLzZ7v+2w5efPpMtJv1nZpOnilPIiKVfP08/lvXU7vVU/KFswmbUavlY5frZO6ZfLI+O61xK2lck30SZMmSdGiRSVLlixSq1Yt2bFjh81pDx06JG3btlXTo6+V8ePHJ/9zEREREaWBTB1EhxyB3ioD9LUncomft2vKKTwql+Ahr9fPLaPaFpLsgZm2gQBRppYrq4982b6QdKmbS5V0ctX+CHXP32yYWz5/oaBqGUNEKbNhwwbp3bu3bNu2TVavXi0xMTHy9NNPS0REhKQXE8aPk27de0iXV7tJ2XLl5NvJU8U/IEDmzplldfpJE7+Rp5s1l37vfyhlypaVwUOHS5Wqj8vUyRP1LPRJE8bLgI8/leeebyUVK1WSGbO/l8thYfLb0iVqmqNHjsifq1bK5O9mSM1ataTeE0+o7PeF8/8nYWFh4s5erl1IFu8Jk2X7rsiZGw9k5IpjEhkTL62q5E90/zuiTTn5bsNZuXTnv+xyzUs1C8rMTedkw/EbcvJahAxeekRyB/lKozK51PMh/j5SJGeAzP77nHoeGerf/nVa/H29pESeQHFXvZ8pK3PXnZSfNp6WY2F35b3Z2+VBVJy83LCk7ReZRK7djdSH6+H/3biBt5qXlbFLD8jvuy/KoQt3pOfULZIvJEBaViuknn+sQLA8VTlU+szYJrtO3ZRtx6+r7Pe2tYtKvhB/cVepWRN9/vz50q9fPxk8eLDs3r1bKleuLM2a2b4R9+DBAylevLiMHj1a8uXL54RPR0RERJS6Mn0QHVCLuG21HDLz1WLyVLlgNc4rDYJXqnNTEWlWIZvMerWYtHk8u3inxRsTUbrl4+0pHWo82h89WfbR/igtgule/9ZAbVEpRL3381Wyq86NidxFo0aN5J133pH+/ftLjhw5VFAGpViMzp8/L61atVKlQoKDg6VDhw5y9epVs2kQ0MmbN6/KGu/evbtZ1rRmxowZUrZsWZVtWaZMGZk8eXKiy7Zy5Up59dVXpXz58iqwNGfOHLUsu3btkvQgOjpa9uzeJU82aaqPQ2mVJ59sKju2bbX6mu3btkrjJ/+bHp56upkaD2fPnJErV66oeWiyZcsmNWrW0qfB/yEhIVKtenV9GiwD3nvnju3irtARc5n8WWXHmdv6OFTp2nHmllQs+Gi/bk2PBkXldkS0LN17OcFzoSFZJFeQn2w3zPN+VJwcvHRPKoU+muedhzFy9kaEPFspn+rLwsvDQ9o+XkBu3o+WI5eTLiOTHvl4eUqVYjlkw6H/1onJJOpxzZKPbh5YE5jFWw6Mby0Hv2kj895rKGVCs+nPFcmdVQXCNxy8oo8Lfxgju07dkJqlcqvHNUvmljsRUbL3zC19mvUHr0i8ySTVE3nfzFwTfdy4cdKjRw/p1q2blCtXTqZOnSoBAQEya5b1G3FonTN27Fjp1KmT+PmxxRsRERGlf0x5NkAG+DtN80nLyiHyw5Yb8s+5B4+uev69+HEGj3/nhdhU9aKB0qVOLin2//buAzyKenv4+AkhIRBCh9AFJBTpvUkRVNqVdkUEFKTIRYogCohSVURQxIbS/gIiiICIvqAgVUVAqkgXkSZC6EkIJW3f5/xyd+9uyIZN2JDdzffjM8LOzs7OzO7MLGfOnEPpFgDJ3CXzwiOF5V9V88iCrRdl96l0OB75JQYj9HhUp3SwyYC/j9It8GLz5883mZC//vqrbN261QSuGzVqJI888ogkJCTYAuiaGR4XF2eyw7t06SKbNm0yr1+yZIkJvGtJggcffFAWLFggH3zwgcmWtFq4cKGMHTtWPvroI6lRo4bs2bPHBI60VEnPnj1dWs6IiAjzpwb7k3Pr1i0zWEVGRkp6unjxosTHx0uhQqEO4wuFhsqRI4eTfY3WTdfnHaYvFCrh4YmBSQ2gW+eRdJ7WafTPgoUKOTyfNWtWs110/t4qT44AU1JFg9f2LkXHSqkCyWeEaw1zzVLvNmtnss9rXXV1OdpxnvrY+px67vO9MvWJyvLzyCYm4HslOlYGf7FXom56Zx3v/CHZTG13zSa3p4/DivwvMG7v6NlIGTR7qxw4dVVy5QiQwW0ekDXjWkqDl1fKP5evS2iexDKO55Nkp+vjQrkTnyuUJ0guRP5vH1TxCRa5ci3GNk1mqIme9Nijwe7kAt56IU4vCo4aNco2Ti+GPfzww+ZYDADI3PQORf3trb83AXfz9/c3/4bQ8nDpjSB6Mu4vGCTj2xeXiOtx8vPRa7L+UIT8EX7L/KDMkkV/RKduflqqMiEhMfCldY9bVMwlD4aFUCYBwB1pzwZtNHwlWo9HUbL+UKT8ed49x6MKdsejkCCOR/B+VatWNaUEVFhYmAl0r1+/3gTR9c99+/bJ8ePHpUSJxJINn332mckO37Fjh8mK1Jq8mn2ug3rjjTdk3bp1DtnoOv+pU6dKp06dzOPSpUvLwYMHZebMmS4F0TWYP3ToUBPcr1y5stMa6hMmTHDLNoHnyxHoL6+1ryhvrDxissnvxsjWYXI5Olb6ztsjt+LipUONojKtSxXp8X+75GKSoL6v2vHnRTNY/Xr0gmyf0k56NQ+Ticv2SqaWyii69Vhpf/xLeoeP/YU4vYvHnj4+fDj5C3HIvE2sAWQueqH17NmzpowXkF707rciRYpIYGD69gEiiJ6C3Dmyyr+q5THD2YgY2XXiupy8dEv+unDL/HkjNuV80OwBflKqQDYpXSCbye7UzPPCuVNuKAUAzu6U0RIrOvxzNUZ2noiWk5di5PjFxOPRzTsdjwKzSKn8gaZxqR6P6pQKlkK5OB7B94Lo9vSHlLUe76FDh0xAyD4opCUHtJyIPqdBdP2zf//+DvNo0KCBbNy40fxda5gfO3bMBNk1+9xKM2u0VIkrNPt9//79snnzZqfTaDanZtSLXTZo0mCWOxUoUMBkcJw/71ja5nx4uNNaxaGFC5vnHaY/Hy6hoYnTW1+n0+jnYD/PqtWqJ84jtLBcSFIvWbfl5cuXzfy91dXrsRKXkOCQIa7yBwfIxWuO2c2qeN7sUixvdpn2ZBXbuCz/zaT59dWm8u+Pf7VltecLDnQIhuvjP84llmqpUyqvNA4rIA+9/bNExyRmer31/R9Sr3Q9U+Jl3pZT4m0uRd2SuPiE27K/9fH5iNvrxicnLt4iv5+4LKVDQ8zj8KuJF8UK5QqScLva8/p436nEcjnnr96Ugkkal2qJs7w5A2/LivcmrtY7t05z+vRpU/rKirIrnk/vpNIyOXo3kJYP+/DDD6Vu3boZvVgAMilNHtEEFv2dWbRoURPgvBfZwshcdznExMTIhQsXzHdNE6n0brj0QhDdRUVyB8q/qgU6fFCXouPk7NVYuRVnkdj4xACWNgPUBqU6fb5gfw4QANyuaJ5AaVc9yfHoWpycjUj+eKTT583B8Qi+LyDA8cKQfuf1x7u7XLt2zfw5e/ZsqVevnsNz+o+DOxk0aJCsXLlSfvrpJylevLjT6ZyVTEgv+g+aGjVrycYN66Vd+w5mnG63jRvXS/8Bg5J9Tb36DWTTxvUyeMhQ27j169aa8apU6dImkK7zqFa9uu1igNY6f/Y/z9nmcfXqVdm9a5fUrFXLjNu0cYN5b62d7q3iEixy+Ow1E9TedCQxI1qPvnVK55UlO87cNv2Ji9fliRnbHcYNeKi05AjMKu+sOSrnIm6ZeV6MuiV1S+eVP8ITv4fBgf5SuViILNuVOE+tg64SklxT1T3AW4//sfEJpi5500qFZdWuv804XZUmlQrL7LV/uDQPvSDxQIk8snZvYrPakxeuybmrN8w8rUHzkOwBUuv+AvJ/6xPnuf3PC5InOJtUK5VP9p5IrIve5IHCZl477bLcvY2r9c6t02gA3T6IfqcLcUl7TOhjmobeO9bmrlqPXs9ReneVNnc9cuSIFEpSOgsA7gUNburvOk0G0UxhID1kz57d/Dvw5MmT5junfavSC41F00j/MVIgZ4BUKZ7DZJg3uD+nGWrdFyyVi+WQ/DnvTT0eADDHoxDnxyOtr87xCJmdNgLVrEodrLQMiwZxNSPdOo3WU7e3bds2h9IEmkXz119/SdmyZR0GLevijF7o0gD6119/LRs2bEhx2ozy/NBhMvf/Zsvnn82Xw4cOyfMDn5Pr0dHSo2cv83yfZ3rImFf/V+944KAh8sOa1fLetKly5PBheeO18bJ7105b0F2POQOfHyqT33xDVv6/b2X/vn3Sp1cPKVK0qC1QX6FiRXm0ZSsZ2P9Z2bF9u2z55Rd5Ycgg6dzlSbOdvdnn205Lx5pFTAZ4qQI5ZFSbcpI9wF++3ZvYIHNC+4oyqHlirf2Y+AQ5diHaYdAa5tdj4szfNYCuFm3/W/o8eJ80KZdfyhYKltc6VJQLUTGy6XBiUHff35ESdTNWJrSvIGGhwVIyX3YZ0uJ+05R0sxcHfqd/f0h6NAuTro3LSLmiueTdXvUkOFtWWfjjMfP8jP80lLFPJF6oUSM6VJGHKhcxDUQ1CD5rQCMpUSBYPtv4p22aT1Yfkpc6VJbWNYvLA8XzmHmcu3pdVu1KPD788U+krN17Rj7oW19qlskv9cIKyts968hX206YALy3V3NxZUjthbhatWqZsllWGjTRx3o3jy/x5CbWqW3uCgD3SnpmBgP38jtGJjoAAPB52uCuSpUq0r17d5Odp2VDBgwYIE2bNpXatWubaYYMGWKakepjrVmuTUQPHDjg0FhUa5VrAEXLt7Rq1co0AN25c6dcuXLFoQRL0hIuixYtkm+++cYETKxNN3UemjnhCTo/0UUuXrggr00Ya5p6asmVb1auttU4Pn36lMOP0wYNG8q8BYtkwrjRMm70K1I2LEyWfLVCKtnVeX/xpREmED/ouX7mYkXDRg/KtytXO2SHzP1soQmct2nZwsy/Q8d/y9T3PhBvt/bgecmbI0D6Ny1tyrpo9vjgRb+beuWqcK5s5uJKaszfcsoE4l9tW15CgrLKb6ciZPCivSYIr7Se+qBFv8vAh8rIjKdqSFZ/P/nrQrQM+3KfHA2PFm/19a8npUCubPLKv6tKodzZZd/JK/LvKRvkwn8bgxYvEGyaqFrlCQ6UD/rWM9NejY6R305clpYT1siRfxIb+qr3Vx40gfj3eteT3DkCZdsf5808b8X+786VZz/+xQTOvxn1sJn//9txSkZ+lnzjV5/tLJoKevzTvhB6/NTyIXqc1RJYGtBVPXr0kGLFipmeD0ozxfRCpvXvZ86cMfXANfCsFyY9mSc2sU5Lc9d73cQaAKy0/+D1GPfdLWqVIzCLKcsMpBc/S2p/wQMAAHhgdmD16tVN4MaqQ4cOpub5vHnzbNmBgwcPNtmRGlzQILjWi7Vvhvfmm2/KtGnTTFbgv//9b/PcmjVrHJq9aUBca85qAEgDGhqc12ahHTt2THbZnN0JMnfuXBN8uRMNbGjAPfxShEulFZCyRpMSa9zDPY4dub1EDdLGEntDIpf0k4gI9+7r1mPI7qPnJGfIned7LSpSaoYVTvVyaMDXWo9bj8caGLaWvtJjdKlSpWzH4xMnTiR7V45e2LQGmz2Rroc2Uf35559t4/SiQfPmzU12+dq1a6V169YOTaz1XKFNrLdv3276bzRs2NAExjWIblW/fn1z3rGea/RCwuuvvy5du3a1TaPNrr/77jvZsmXLbcv1zz//mIsU+px99r9mzGswP+ldVkoD+ck1sXb39w9A5qXHNT0e6vHemkShAfQpq89J1M3E/i3uFBLkLyNaFSaQngndTOa7Zv39487zGt8sAADg9ZILuqxYscLhccmSJU02eEpeeeUVM9ibPHmyw+Nu3bqZwVXkKwDwBHo9L0sqaqKnlpat0sGVY7QG1L312OgNTaxdca+bWAOA0gx0DaAH+PuZHl7uEhNnMfPV+ee+Q/l1PQfpvxP0gm960HOeBnU1YSc5eoeSngOtZbr+/vtvc37Qso9axutOOnfubI7feu6w3tmk/Zb0/KHniaeeesqcj1Pq2aQlv6KiomT48OHiThs2bDB3Zk2dOtUkGamXXnpJatasmap/P3kqgugAAAAA4OvSsZxLZuKJTazT0tz1XjexBgB7GkC3NkV3jwSJjfeMi7MaRNdShs6C6FOmTDEBfL17Sctu9e7dW1588UWXAuh6V9Ply5cd7jqylqtU2rtJg+h6MVbvCHMm6cVcd4iIiJCXX35Z2rRp4zBe74rS8mVa2iylwL43oLo/AAAAAPg4v1T8B+9qYp2ZmrsCgLvLdGmmdOPGjeX+++93CC5r2UUNcGsZrnLlypmeFDdu3LA9Z19GUuehWeFalkuzvLW3hQbKX3vttdveU8tBallHvdtIS4FpBrmz3kpJzZw5M8WMbu2voQ2lP/nkExPUdkaX1ZoprqXWNJivJcS0TKX2N9FzUGoNGjRIRo8eLfnz53cYX6hQIbNtf/jhB/F2ZKIDAAAAgI/TMi1+6VjOBRnbxPpOzV0BAMnTrG0tqRUbG2sueGpDZusFSL3oqRc6c+TIYfotae+kpKUf7WngXAPxevHUPsielGZmt2zZUsaNG2fOAdqvydUs9xdeeCHFaSpUqGCW98iRI+Z84IodO3aYCwB6sVazybWcpQbsteSLXmBITuh/e0epZcuWmXVo166dLF++/LZpdXvqhV3tG+LNCKIDAAAAgI+jmkv609Iu2ntDm1g3adLEoYm1ld7OrgEbvb3d2sT6ueeeswUiVN++fU0ARBu1ar1a+ybWzuh8L1y4IGPHjrU1d129erVD82wAQPLHz6xZs5pBj516jLYG0Z944gkJCQkxf9deFVoiJaUgempKd2lQuWDBgiaIHhYW5tLrtH66K8f11PYd0fW13u2kf7eet3TdrU2vndFzjja/TqkxuJYW0zuzvB1BdAAAAADwdUTRfbqJ9Z2auwKAJ9FGoFrH3L3zS5ugoCDb37Vmt95FlNLFUqUB9/j4eNt4vSiaM2dOl99Ty79oVrbeuaQXUzXbO2kZlOToBVZ9r5RoBrqWndGM9LvdBq5kou/atUvOnj1ra9R68eJF+fbbb82F3YkTJ5pxuszZs2cXb0cQHQAAAAB8nKv1zqmJDgBILzkCs0hIkL9E3Yx3eyNQna/O3520TIk2/dQAsNYx17JdSvtUaJNPdenSJfnuu++kR48e5nGuXLnk5MmTTuepgWfNQt+7d68JimsjUL2DadGiRXdcnqpVq5ogeYkSJZJ9/sSJEyZjXu9w0uW4W65kordt29ahsbWWLNOAuv3dU4cOHZJq1aqJtyOI7oKffvrJ3GLhSqdcAEhPHI8AAECaE9FdqYl+LxYGAJAp5c6RVUa0KizXY9yXhW6lAXSdvzvVqVPH1C7XrGotc2INDPfr108ef/xx8+9y7WlRv35922s6duwoCxYsMIHkTp06mTJbVlorXRuKasBcA+hKm4/WqFHD1BLX6VOi76lBeGswX2lvjR9//FGuX79uAuea3a5BeU9hsVjMRQOtte7t/CypLZSTyRw/flxmzZplbmVo3769fPHFFzJ9+vSMXiwAmRDHIyBzioyMNM3lwi9FuCWjJLNrNGljRi+CTzl25ExGL4LPsMTekMgl/SQiwr37uvUYcuD4eQlxYb5RkZFSqXQhty8HPJv1e+Jpn/vZj0dmyPsWGeBYXge+x/67xeedPrSEh/4bVmtt25cL8RbJZVRnNK2l3rBhQ9P8VPtleIPVq1fL559/boZ7+V1Lj/Mamegp0OsL+iHrFZyjR4/KV199lep5/PHHH7J06VL566+/JCEhwdzyoV3Tixcvni7LDMA3cTwCAAB3Q7PQXcpEJxUdAACPpHXXp02bZgLGlStXFm8QEREhU6ZMEV9AED0F2jBgzJgx5u9FixY1NZDmz5+fqnlER0dLs2bNzJWrbNmymXpKWlhfs0e1WzsAuILjEQAAuDt0FgUAwFXz5s0TT9SiRQuXptNa5ppNn5Qm0r3wwgtyr3Tp0kV8BUH0FGhzgE8++cRkfRYuXFjq1auX6nloXSN77dq1M3WOtJ6SdrIFAFdwPAIAAHeDTHQAADIPLUVzp6agSB2C6Cn44IMPTAM/rUF88eJFefPNN23PzZkzRzZv3uz0tVowv0KFCreNP3jwoKlbVKBAgXRbbgC+h+MRAAC4G+ShAwAApB1BdCc0SHXo0CEZNmyYKXtQrFgxeeSRR2Tt2rXm+b59+5ohtfOcPXu2PP300+Lv759OSw7A13A8AgAAd4tMdAAAgLQjiO7ElStXJCAgwHRytdIs0LspxfDaa69Jy5YtpXnz5m5aSgCZAccjAABwt/z++58r0wEAkF7io65Iws3rbp9vlqAc4h+S1+3zBawIojuRN29eiY2NNV1krYErzdy00pIKP//8s9PXv/LKK1KxYkVbwGrChAnSuHFj6dSp0z1YegC+hOMRAAC4a9RzAQB4QAA9fP5ESbgR7fZ5Z8keLKE9XyWQjnRDEN0JrRFcvnx5WbhwoSmToAGrdevW2Z7v16+fGe7k8uXLJmDVsGFD6dy5czovNQBfxPEIAADcLWLoAICMphnoGkD3889qBnexxMeZ+er8CaIjvWRJtzn7gCFDhpisTQ1avf/++/LQQw+leh7r16+Xc+fOyapVq0ztYeug9Y0BwFUcjwAAgDtqorsyAACQnkwQPSDQfUMqAvIxMTEycuRIKVu2rLlju0qVKjJ//nyXXnv16lV56623xB1WrFgh27Ztc/p827ZtZcqUKbbHe/bsMf3Rzp8/bx6XKlXK6Wv37t1rXm/l5+dn1rNq1apSrlw56dq1qxw8eFDSw9U0bqMNGzZI3bp15YEHHpBKlSrJiBEjJCEhwTwXHh5unouLi5OMRCb6HbI/x4wZ4zAuteUPNNuTjE8Ad4vjEQAAuBvURAcAQOSZZ56RW7dumUBzcHCwnDhxQlq3bm0CtH369HEpQPzyyy+7JYhevXp1qV+/frLPz5kzR2rVqmWC4Rrw79Gjh0moK1So0B3nPWrUKDPY0xKwefLkMYFpLQnbqFEj2b17t5QuXVrc6Woat5GWsV28eLGUKVNGbt68KQ8//LB89tln5vMKDQ01d9Tr4969e0tGIRMdAAAAADJLPRdXBgAAfNDRo0dN8FqDyBpAt2Z0T5061ZQ+VZs2bTLBbav9+/fbsr779+8vUVFR5vnatWubcc2aNZPBgwdLnTp1TLD7xRdfFIvFYntO38/q8ccfl3nz5sl3330n3377rbz99ttmXhowT6pIkSLyzjvvmOC5BsQrV65sXm9VsGDBZNfx1KlTcuDAAdMHLTlZsmQx69GyZUv5+OOPU9xea9askZo1a5oM9qZNm9qy11O7jVxRo0YNE0BXQUFB5vV6gcNKs+dnzpwpGYlMdAAAAADwcdREBwBkdloSJSwsTPLnz+8wvkGDBnL69Gm5cOFCiq+fMWOGCe7+9ttvDuM1uLxlyxaJjY2VJk2ayBdffCHdunVzOp82bdpIu3btzLyGDh3qdDqdh5aa0QzsI0eOODy3Y8eOZF/z448/moD+ndSrV0/Wrl3r9HktG6PvrwFzLQWzcOFCE8TXAH1qt5FeLNDXJ2fcuHHSsWNHh3FahnbZsmWycuVK2zjNyv/9998lMjJScuXKJRmBIDoAAAAA+DhX651TEx0AgNTRbPGAgAAzPPXUU7Ju3boUg+iu+ueff2Tfvn2SNWtWOX78+G3B/+T8/fffpvzJnViz5Z359ddfTfBcB9W9e3cZOHCgnDlzRlJr+PDhZnCFBskfe+wxUxPdPpNdt4GWfNFtQhAdAAAAAJBOXKuJTi46ACC9WeLjMmR+WjJES7pcunTJISC9detWKVGihCmRosHa+Ph423Nanzu1tJGnutt5aY12LQ9TsmRJUxtca5gHBgam+JocOXK49D6aya4lYtIiayrXy9VMdC0D06pVK2nfvr0MGzbstmn1fbJnzy4ZhZroAAAAAJBJMtFdGQAASA9ZgnJIluzBJuidEHPTbYPOT+er80+JlnLRLOd+/frJ9evXzTitu62B6jFjxpjHWpf75MmTttIuCxYssL1eM6Bv3LghMTExDvP9/PPPTSkXfW7RokWmKabSGuma0a00k3zz5s0O84qIiHC6rFr/W4PKL7zwgnTu3FkqVaok48ePv+M21vrlSUu/2NPGorNnz5bVq1fLc88953Q6bXiqWfBa71wtXrxYihUrZobUbiPNQtfyLskN1gD6tWvXTABdh9GjR9+2POHh4ebihF7syChkogMAAAAAAI9TZMDkjF4E+Ci+WxnDPySvhPZ8VRJuJgaw3UkD6Dr/O9H64hqk1TIlmtXt7+9vgry9e/c2zxctWtSUEqlbt64pi9K6dWvba/Ply2dKt2igOmfOnLJz504zvmLFitKoUSO5fPmyyaJ+8sknzXidT5cuXcx7aRBc65BbPf300ya7XBuPapmUvn372p7TgLtmaGvQXRuBqunTp0u1atVM0DmlmucPPvigKemiy6LLa6WNRjUIrdnc2iz0l19+kdKlSzudj2bla/a4rm9cXJwppbJ06VIzj7Rsozt5//33Zfv27RIdHS3Lly834/Tiwauvvmr+rkF/XXfr9sgIfpY7FcEBAABAhtG6gLlz55bwSxEZVv/PlzSatDGjF8GnHDuS+rqYSJ4l9oZELulnstLcua9bjyEnz112ab46/X2F87l9OeDZrN8TPncA7qLBWg0Ga6A2KChIfFWzZs1Mc9AOHTqIp9DyKcrVOuTeoHHjxjJr1ixzwcKV71p6nNco5wIAAAAAmaIiumv/AQAA7zVkyBCTBe4rwsPDTemZ5ALo9xLlXAAAAADAx7la75ya6AAAuG7Tpk3iabRMTUr1zu31799ftm3bdtt4bbaakU087WnJmG7duklGI4gOAAAAAD5OY+OuxMeJoQMA3EkbWcJzzZgxQ7xdwj36jhFEBwAAAABfRxQdAHCPs6G1CeQ///xjmlTqY21KCbiLtvmMiYmRCxcumO+afsfSE0F0AAAAAPBxrtY7pyY6AMAdNKipjR7Pnj1rAulAesmRI4eULFnSfOfSE0F0AAAAAPBx1EQHANxrmhmswc24uDiJj4/P6MWBD/L395esWbPek7scCKIDAAAAgI9L72ou06dPl7ffflvOnTsn1apVkw8//FDq1q3rdPqlS5fKmDFj5MSJExIWFiaTJ0+WNm3apPHdAQCeSoObAQEBZgC8WfrmuQMAAAAAPCeK7sqQSl9++aUMGzZMxo0bJ7t37zZB9JYtW8r58+eTnX7Lli3StWtX6dOnj+zZs0c6dOhghv3799/9egIAAKQDgugAAAAAkElqorvyX2q9++678uyzz0qvXr3kgQcekBkzZpj6pJ9++mmy07///vvSqlUrGT58uFSsWFFef/11qVmzpnz00UduWFMAAAD3o5wLAACAh3edV1GRkRm9KD4h/mZ0Ri+CT7HE3sjoRfC5bWnd590tKirSpXrnOp2KTHLMyZYtmxmSiomJkV27dsmoUaNs47Sx18MPPyxbt25N9j10vGau29PM9RUrVri6OnAz6/cu6ecOAIA3ivzv+cydv6sIogMAAHiwqKgo82fZ0iUyelEA3KN9Pnfu3G5t6la4cGEJS8UxJGfOnFKihOP0Wqpl/Pjxt0178eJF0ywuNDTUYbw+Pnz4cLLz17rpyU2v45Gx55qknzsAAN7s0qVLbvtdRRAdAADAgxUtWlROnz4tISEh96Tr/N1ke2jwRZc1V65cGb04Xo/tmfm2pWZKaSBT93l3CgoKkuPHj5uM8dQsS9LjTXJZ6PDtc4237Dvuxnqz3plBZlzvzLjOmXm9IyIipGTJkpIvXz63zZMgOgAAgAfTsgjFixcXb6E/zjPTD/T0xvbMXNvSnRnoSQPpOqSHAgUKiL+/v4SHhzuM18eaAZ8cHZ+a6ZGx5xpv2HfSA+udubDemUdmXOfMvN5ZsrivHSiNRQEAAAAAaS4XU6tWLVm/fr1tXEJCgnncoEGDZF+j4+2nV2vXrnU6PQAAQEYjEx0AAAAAkGbaJLRnz55Su3ZtqVu3rrz33nsSHR0tvXr1Ms/36NFDihUrJpMmTTKPhwwZIk2bNpWpU6dK27ZtZfHixbJz506ZNWtWBq8JAABA8giiAwAA4K5pvWRtPEjdZPdge7oP2zL9denSRS5cuCBjx441zUGrV68uq1evtjUPPXXqlMPt1A0bNpRFixbJ6NGj5ZVXXpGwsDBZsWKFVK5cOQPXAkll1n2H9Wa9M4PMuN6ZcZ0V653NbfP0s2jXGAAAAAAAAAAAcBtqogMAAAAAAAAA4ARBdAAAAAAAAAAAnCCIDgAAAAAAAACAEwTRAQAAcNfGjx9vmgnCPdie7sO2BAAAwN0iiA4AAACPMX36dClVqpQEBQVJvXr1ZPv27Rm9SF7rp59+kscee0yKFi0qfn5+smLFioxeJK81adIkqVOnjoSEhEihQoWkQ4cOcuTIkYxeLMDtLl++LN27d5dcuXJJnjx5pE+fPnLt2rUUX9OsWTNzjLEf+vfvL750rlm6dKlUqFDBTF+lShX57rvvxBulZr3nzZt32+eqr/P18+CmTZukZs2aki1bNilbtqzZDt4mteut65z0s9bh3Llz4uvnaW/ft9Oy3r6wb3/yySdStWpVc67SoUGDBvL999+n+2dNEB0AAAAe4csvv5Rhw4bJuHHjZPfu3VKtWjVp2bKlnD9/PqMXzStFR0ebbahBE9ydH3/8UQYOHCjbtm2TtWvXSmxsrDz66KNmGwO+RAPoBw4cMN/zlStXmmBcv3797vi6Z599Vs6ePWsbpkyZIr5yrtmyZYt07drVXFDYs2ePCVLpsH//fvH1c6wGp+w/15MnT4ovnwePHz8ubdu2lYceekh+++03GTp0qPTt21fWrFkjmeH8r8FX+89bg7K+fJ72hX07rb9PvH3fLl68uLz11luya9cu2blzpzRv3lzat29vzl/p+llbAAAAkGk0bdrUMnjwYMvw4cMtefPmtYSGhlrGjRvnMM3Jkyct7dq1swQHB1tCQkIsnTt3tpw7d85hmkmTJlkKFSpkyZkzp6V3796WkSNHWqpVq+YwzezZsy0VKlSwZMuWzVK+fHnL9OnTU1y2unXrWgYOHGh7HB8fbylatKh5L0/lydvTnv7s//rrry2ezFu2pTp//rzZpj/++ONdrDHgWQ4ePGi+1zt27LCN+/777y1+fn6WM2fOpLjvDhkyxOItUnuueeKJJyxt27Z1GFevXj3Lf/7zH4s3Se16z50715I7d26Lr3DlPDhixAhLpUqVHMZ16dLF0rJlS4svr/fGjRvNdFeuXLH4ClfO076yb6d2vX1t37bS345z5syxpOdnTSY6AABAJjN//nwJDg6WX3/91WQLvvbaayZ7RSUkJJhMDr2lX7NbdPxff/0lXbp0sb1+yZIlps70m2++abI/ihQpIh9//LHDeyxcuFDGjh0rEydOlEOHDplpx4wZY947OTExMSab5OGHH7aNy5Ili3m8detW8WSeuD29lbdsy4iICPNnvnz53LbuQEbTY62WcKldu7ZtnB6D9Vis+2RKdL8qUKCAVK5cWUaNGiXXr18XT5SWc42Ot59eaQa3p5+b3HGO1VI+9913n5QoUSLFLE9f4Quf9d3Q/iF63nzkkUfkl19+EW/mynnaFz9vV3+f+NK+HR8fL4sXLzbZ91rWJT0/66x3taQAAADwOlpDUG/nVmFhYfLRRx/J+vXrzT+a9M99+/aZW5r1h7X67LPPpFKlSrJjxw5Td/G9994zt0PqoN544w1Zt26d3Lx50/YeOv+pU6dKp06dzOPSpUvLwYMHZebMmdKzZ8/blunixYvmR3BoaKjDeH18+PBh8WSeuD29lTdsSw3m6y3+jRo1MgFDwFdo/eOk5RuyZs1qgjEp1Ubu1q2bCcZo/eXff/9dRo4cacpCLF++XDxNWs41uu7JTe9N9aLTst7ly5eXTz/91ByXNTD3zjvvSMOGDU2wTUsp+CJnn3VkZKTcuHFDsmfPLr5IA+czZswwF9Bu3bolc+bMMb0O9OKZ1of3Nq6ep31h307LevvKvr1v3z4TNNffeDlz5pSvv/5aHnjggXT9rAmiAwAAZDL6oznpP56sNVE1M1cDlNYgpdIfpJqdqM9poFL/TNo0Tn/Ebty40fxdM0GOHTtmAplaJ9cqLi5OcufOLb6G7Zm5tqXWHtUamps3b76rdQXulZdfflkmT56c4jS676SVfc10bdam+22LFi3Mvnb//feneb7IWHrstM/q1CBbxYoVzQXH119/PUOXDe6lQVUd7D9r3X+nTZsmCxYsEG+TWc/Trq63r+zb5cuXN70L9ELAsmXLTCKE3qnoLJDuDgTRAQAAMpmAgACHx35+fiZ7xV30FlE1e/ZsqVevnsNz/v7+yb5GywDoc+Hh4Q7j9XHhwoXFk3ni9vRWnr4tBw0aZGu26E3ZWsjcXnzxRXnmmWdSnKZMmTLmWJu0yaReYNISSqk5Dlv3rT///NPjguhpOdfoeG88N7n7HKvH5xo1apjP1Vc5+6y1CaOvZqE7U7duXa8MQqfmPO0L+7Y7fp94674dGBgoZcuWNX+vVauWuSvx/fffNxcD0uuzpiY6AAAAbDQT5fTp02aw0lIXV69etWV26DRJ6+Nu27bN4fZIva1f61Xrj1v7QUtnOPshrD+AtWSHlQZP9bGz+obeIKO2py/KyG2pvdn0H6h6q/CGDRsy1XaH9ytYsKBUqFAhxUGPwXqs1f1Ja2db6fddj8VJLzqlRDMDlWake5q0nGt0vP30SnsyeNO5yR3nWC0Ho+UTPPFzdRdf+KzdRfdjb/qs03Ke9oXP2x2/T3xl305ISDDliNLzsyYTHQAAADbadEdvx+/evbupL61ZiAMGDJCmTZvams0NGTLEZDXqY627qA3ltI6iZjJaTZgwQZ5//nlTIqNVq1bmR602erxy5YoMGzYs2ffW8Xorps5XM6D0/bX8Rq9evcRbZeT21Kxr+6wirSWu/yjW+sYlS5YUb5OR21JvkV60aJF88803EhISYquhqfPIbNmJ8F16EUr3CS11pPWRY2NjTXDmySefNBef1JkzZ0ypFu1HoMdpLfmg+0abNm0kf/78pib6Cy+8IE2aNLmtPJOnuNO5pkePHlKsWDGZNGmS7biixxntpdC2bVvTwE6PGbNmzRJvktr11sbO9evXNxcZ9eLK22+/LSdPnpS+ffuKt7jTeVCb4Op3Wr/PSsuBaS+OESNGSO/evU1QUhtWr1q1SrxJatdbvwsafNUeI1pfWmui67r/8MMP4i1cOU/74r6dlvX2hX171KhR0rp1a/N9joqKMttg06ZNsmbNmvT9rC0AAADINJo2bWoZMmSIw7j27dtbevbsaXt88uRJS7t27SzBwcGWkJAQS+fOnS3nzp1zeM3EiRMtBQoUsOTMmdO8dsSIEZZq1ao5TLNw4UJL9erVLYGBgZa8efNamjRpYlm+fHmKy/fhhx9aSpYsaV5Tt25dy7Zt2yyezJO358aNGy36cz/pYL9snsSTt2Vy21GHuXPnum39AU9w6dIlS9euXc3+kytXLkuvXr0sUVFRtuePHz9uvvt6fFGnTp0y+0++fPks2bJls5QtW9YyfPhwS0REhMWTpXSu0WNR0uPkkiVLLOXKlTPTV6pUybJq1SqLN0rNeg8dOtQ2bWhoqKVNmzaW3bt3W7zJnc6D+qeud9LXWM8PZcqU8crjfGrXe/LkyZb777/fEhQUZPblZs2aWTZs2GDxJq6cp31x307LevvCvt27d2/LfffdZ9ahYMGClhYtWlh++OGHdP+s/fR/6XFVAAAAAAAAAAAAb0dNdAAAAAAAAAAAnCCIDgAAAAAAAACAEwTRAQAAAAAAAABwgiA6AAAAAAAAAABOEEQHAAAAAAAAAMAJgugAAAAAAAAAADhBEB0AAAAAAAAAACcIogMAAAAAAAAA4ARBdAAAAAAAAMAHlSpVSt57772MXgzA6xFEBwAAAAAAgFd55plnxM/P77bhzz//dMv8582bJ3ny5HHLvAB4v6wZvQAAAAAAAABAarVq1Urmzp3rMK5gwYLiaWJjYyUgICCjFwPAXSATHQAAAAAAAF4nW7ZsUrhwYYfB39/fPPfNN99IzZo1JSgoSMqUKSMTJkyQuLg422vfffddqVKligQHB0uJEiVkwIABcu3aNfPcpk2bpFevXhIREWHLcB8/frx5Tv++YsUKh+XQjHXNXFcnTpww03z55ZfStGlT8/4LFy40z82ZM0cqVqxoxlWoUEE+/vhjp+s2a9YsKVq0qCQkJDiMb9++vfTu3dv8/dixY+ZxaGio5MyZU+rUqSPr1q1zOk/rsv3222+2cVevXjXjdJ2t9u/fL61btzbz1Hk//fTTcvHiRZc+E8BXEUQHAAAAAACAz/j555+lR48eMmTIEDl48KDMnDnTBLknTpxomyZLlizywQcfyIEDB2T+/PmyYcMGGTFihHmuYcOGpo54rly55OzZs2Z46aWXUrUML7/8snn/Q4cOScuWLU0gfezYsWYZdNybb74pY8aMMe+dnM6dO8ulS5dk48aNtnGXL1+W1atXS/fu3c1jDfq3adNG1q9fL3v27DGZ+Y899picOnUqjVsuMajevHlzqVGjhuzcudO8X3h4uDzxxBNpnifgCyjnAgAAAAAAAK+zcuVKky1tpdnTS5cuNVnnGsTu2bOnGa+Z6K+//roJko8bN86MGzp0qEPzzTfeeEP69+9vssMDAwMld+7cJkNbs9vTQuffqVMn22N936lTp9rGlS5d2hbgty6nvbx585r1WbRokbRo0cKMW7ZsmRQoUEAeeugh87hatWpmsNJ1/Prrr+Xbb7+VQYMGpWm5P/roIxNA1yC/1aeffmqy9f/44w8pV65cmuYLeDuC6AAAAAAAAPA6Gkz+5JNPbI+1NIvau3ev/PLLLw6Z5/Hx8XLz5k25fv265MiRw5Q9mTRpkhw+fFgiIyNNqRf75+9W7dq1bX+Pjo42pVf69Okjzz77rG28vqcG653RjHOdXgP7WrpGs9mffPJJk0VvzUTXMjOrVq0y2fI6vxs3btxVJrpuO81+t784YaXrQBAdmRVBdAAAAAAAAHgdDZqXLVv2tvEaXNZsdPtMcCutR661wf/1r3/Jc889ZwLt+fLlk82bN5sgd0xMTIpBdM1Ot1gstzUOTW7Z7JdHzZ49W+rVq+cwnbWGe3K0NIu+lwbJtd65lqmZNm2a7XktMbN27Vp55513zHbInj27PP7442YdkmMNvtsvf9Jl12XV9508efJtry9SpIjTZQV8HUF0AAAAAAAA+AxtKHrkyJFkA+xq165dpmGnllexBpaXLFniMI2WdNHs9aQKFixosr6tjh49arLXU6LNObVJ6F9//WWrZ+4KDfjrhQDNQP/zzz+lfPnyZt2sNNv+mWeekY4dO9oC4HqBwBlddqXLryVblH2TUaXz/+qrr0yJm6xZCRsCVuwNAAAAAAAA8BnawFMzzUuWLGkyszVQrmVK9u/fb2qfa3BdM7A//PBDk3WtwegZM2Y4zEODyBqU1qadWndcs9N10KabWje8QYMGJsg+cuRICQgIuOMyaWb8888/b8q3aAPQW7dumcadV65ckWHDhjl9nQbddV20AepTTz3l8FxYWJgsX77crINmyGujUr044IxmqtevX1/eeustU5P9/PnzMnr0aIdpBg4caDLmu3btamrIa5a+BvAXL14sc+bMSTFzHvBliZfbAAAAAAAAAB/QsmVL03T0hx9+MGVQNHCsZVDuu+8+87wGxd99911TsqRy5com01vro9tr2LChaTTapUsXk8E9ZcoUM16z17XJZuPGjaVbt26mpIorNdT79u1rgtBz586VKlWqSNOmTWXevHkmmJ0SDdprIFsz6/X97Ok6aANSXVYNpOt622eqJ0ebhGrt9Fq1apnmp3pRwZ5mzOtFBb1A8Oijj5pl1eny5Mljy9oHMiM/S9JCTgAAAAAAAAAAwOASEgAAAAAAAAAAThBEBwAAAAAAAADACYLoAAAAAAAAAAA4QRAdAAAAAAAAAAAnCKIDAAAAAAAAAOAEQXQAAAAAAAAAAJwgiA4AAAAAAAAAgBME0QEAAAAAAAAAcIIgOgAAAAAAAAAAThBEBwAAAAAAAADACYLoAAAAAAAAAABI8v4/nhiIwyZLf5cAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ── Visualise the graph and the normalised adjacency matrix ──────────────────\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "fig.suptitle(\"GCN Layer — Worked Example (N=3 nodes, D_in=4, D_out=2)\",\n", + " fontsize=12, fontweight=\"bold\")\n", + "\n", + "# ── Panel 1: Graph structure ──────────────────────────────────────────────────\n", + "ax = axes[0]\n", + "ax.set_title(\"Graph structure\\n(edges 0↔1, 1↔2)\", fontweight=\"bold\")\n", + "ax.set_xlim(-0.5, 2.5); ax.set_ylim(-0.5, 1.5); ax.axis(\"off\")\n", + "\n", + "node_pos = {0: (0, 0), 1: (1, 1), 2: (2, 0)}\n", + "for u, v in [(0,1),(1,2)]:\n", + " x0,y0 = node_pos[u]; x1,y1 = node_pos[v]\n", + " ax.plot([x0,x1],[y0,y1],\"k-\",lw=2,zorder=1)\n", + "for nid, (nx_,ny_) in node_pos.items():\n", + " ax.add_patch(plt.Circle((nx_,ny_), 0.18, color=\"#4a90d9\", zorder=2))\n", + " ax.text(nx_, ny_, str(nid), color=\"white\", ha=\"center\", va=\"center\",\n", + " fontsize=13, fontweight=\"bold\", zorder=3)\n", + "ax.text(0,-0.35,\"d̂=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "ax.text(1, 1.25,\"d̂=3\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "ax.text(2,-0.35,\"d̂=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "\n", + "# ── Panel 2: Normalised adjacency (heatmap) ───────────────────────────────────\n", + "axes[1].set_title(\"Normalised adjacency\\nD̂⁻¹/² Â D̂⁻¹/²\", fontweight=\"bold\")\n", + "im = axes[1].imshow(norm_adj.numpy(), cmap=\"Blues\", vmin=0, vmax=0.6)\n", + "for i in range(N):\n", + " for j in range(N):\n", + " val = norm_adj[i,j].item()\n", + " axes[1].text(j, i, f\"{val:.3f}\", ha=\"center\", va=\"center\",\n", + " color=\"white\" if val > 0.3 else \"black\", fontsize=10)\n", + "axes[1].set_xticks(range(N)); axes[1].set_yticks(range(N))\n", + "axes[1].set_xticklabels([f\"node {i}\" for i in range(N)])\n", + "axes[1].set_yticklabels([f\"node {i}\" for i in range(N)])\n", + "plt.colorbar(im, ax=axes[1])\n", + "\n", + "# ── Panel 3: Input X and output X' feature vectors ───────────────────────────\n", + "axes[2].set_title(\"Feature transformation\\nX (4-dim) → X' (2-dim)\", fontweight=\"bold\")\n", + "x_np = x_test.detach().numpy()\n", + "xp_np = x_out.detach().numpy()\n", + "\n", + "for i in range(N):\n", + " axes[2].barh([i+0.2]*D_in, x_np[i], height=0.18, left=np.arange(D_in),\n", + " alpha=0.7, color=\"#4a90d9\")\n", + " axes[2].barh([i-0.2]*D_out, xp_np[i], height=0.18, left=np.arange(D_out),\n", + " alpha=0.8, color=\"#e07b54\")\n", + "\n", + "axes[2].set_yticks(range(N))\n", + "axes[2].set_yticklabels([f\"node {i}\" for i in range(N)])\n", + "axes[2].set_xlabel(\"Feature value\")\n", + "blue_p = mpatches.Patch(color=\"#4a90d9\", alpha=0.7, label=\"Input X (D_in=4)\")\n", + "orange_p= mpatches.Patch(color=\"#e07b54\", alpha=0.8, label=\"Output X' (D_out=2)\")\n", + "axes[2].legend(handles=[blue_p, orange_p], fontsize=8, loc=\"lower right\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "213190f2", + "metadata": {}, + "source": [ + "---\n", + "## Section A — Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", + "\n", + "### Data layout on disk (what we actually have)\n", + "\n", + "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", + "which packages PTB-XL records in a flat WFDB layout — **no `ptbxl_database.csv`**.\n", + "\n", + "```\n", + "training/ptb-xl/\n", + "├── g1/ ← group 1 (≈1000 recordings each)\n", + "│ ├── HR00001.hea ← WFDB header: leads, fs, calibration + metadata comments\n", + "│ ├── HR00001.mat ← raw signal matrix (12 × 5000 float, 500 Hz)\n", + "│ ├── HR00002.hea\n", + "│ ├── HR00002.mat\n", + "│ └── ...\n", + "├── g2/\n", + "│ └── ...\n", + "└── g22/ ← group 22\n", + "```\n", + "\n", + "### What a `.hea` file looks like\n", + "\n", + "```\n", + "HR00001 12 500 5000\n", + "HR00001.mat 16x1+24 1000.0(0)/mv 16 0 -115 13047 0 I\n", + "... (12 lead rows)\n", + "# Age: 56\n", + "# Sex: Female\n", + "# Dx: 251146004,426783006 ← SNOMED-CT codes (comma-separated)\n", + "# Rx: Unknown\n", + "# Hx: Unknown\n", + "# Sx: Unknown\n", + "```\n", + "\n", + "### Goal\n", + "\n", + "Scan all `g*/` directories, parse each `.hea` file, and write a single \n", + "**`ptbxl-pyhealth.csv`** that serves as the metadata index for PyHealth.\n", + "\n", + "| Column | Source | Example |\n", + "|---|---|---|\n", + "| `patient_id` | record name (one ECG = one row in this dataset) | `HR00001` |\n", + "| `record_id` | record name | `HR00001` |\n", + "| `signal_file` | relative path to `.mat` | `g1/HR00001.mat` |\n", + "| `age` | `# Age:` header comment | `56` |\n", + "| `sex` | `# Sex:` header comment | `Female` |\n", + "| `scp_codes` | `# Dx:` header comment | `251146004,426783006` |\n", + "| `sampling_rate` | first header line (always 500) | `500` |\n", + "| `num_samples` | first header line (always 5000) | `5000` |\n", + "| `num_leads` | first header line (always 12) | `12` |\n", + "| `group` | parent directory name | `g1` |\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "55a8f37d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CinC 2020 root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", + "CSV exists : True (/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv)\n", + "[INFO] Cached CSV found → /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + "\n", + "Loaded df_meta: (21837, 10) — 21,837 ECGs × 10 columns\n" + ] + } + ], + "source": [ + "import re\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from typing import Optional\n", + "\n", + "# ── Section A paths ───────────────────────────────────────────────────────────\n", + "# CinC 2020 Challenge data: g1/ - g22/ folders with .hea/.mat files\n", + "PTBXL_CHALLENGE_ROOT = Path(\n", + " \"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/\"\n", + " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/\"\n", + " \"training/ptb-xl\"\n", + ")\n", + "# Output CSV (will be cached — skip rebuild if already exists)\n", + "CSV_OUTPUT_PATH = PTBXL_CHALLENGE_ROOT / \"ptbxl-pyhealth.csv\"\n", + "\n", + "print(f\"CinC 2020 root : {PTBXL_CHALLENGE_ROOT}\")\n", + "print(f\"CSV exists : {CSV_OUTPUT_PATH.exists()} ({CSV_OUTPUT_PATH})\")\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Helper: parse a single WFDB .hea file\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def parse_hea_file(hea_path: Path) -> Optional[dict]:\n", + " \"\"\"\n", + " Parse one WFDB header file (.hea) and return a metadata dict.\n", + "\n", + " Header format (CinC 2020 Challenge):\n", + " Line 0 : \n", + " Lines 1-12: signal info rows (one per lead)\n", + " Comment lines starting with '#':\n", + " # Age: \n", + " # Sex: \n", + " # Dx: ,,...\n", + " \"\"\"\n", + " try:\n", + " lines = hea_path.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines()\n", + " except OSError:\n", + " return None\n", + "\n", + " if not lines:\n", + " return None\n", + "\n", + " parts = lines[0].split()\n", + " if len(parts) < 4:\n", + " return None\n", + " record_id = parts[0]\n", + " num_leads = int(parts[1])\n", + " fs = int(parts[2])\n", + " num_samples = int(parts[3])\n", + "\n", + " age, sex, scp_codes = None, \"Unknown\", \"\"\n", + " for line in lines:\n", + " line = line.strip()\n", + " if line.startswith(\"# Age:\"):\n", + " try: age = int(float(line.split(\":\", 1)[1].strip()))\n", + " except ValueError: age = None\n", + " elif line.startswith(\"# Sex:\"):\n", + " sex = line.split(\":\", 1)[1].strip()\n", + " elif line.startswith(\"# Dx:\"):\n", + " scp_codes = line.split(\":\", 1)[1].strip()\n", + "\n", + " group = hea_path.parent.name\n", + " signal_file = f\"{group}/{record_id}.mat\"\n", + "\n", + " return {\"patient_id\": record_id, \"record_id\": record_id,\n", + " \"signal_file\": signal_file, \"age\": age, \"sex\": sex,\n", + " \"scp_codes\": scp_codes, \"sampling_rate\": fs,\n", + " \"num_samples\": num_samples, \"num_leads\": num_leads, \"group\": group}\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Main builder: scan all g* directories → ptbxl-pyhealth.csv\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def build_ptbxl_csv(root: Path, output_path: Path, force: bool = False) -> pd.DataFrame:\n", + " if output_path.exists() and not force:\n", + " print(f\"[INFO] Cached CSV found → {output_path}\")\n", + " return pd.read_csv(output_path)\n", + "\n", + " group_dirs = sorted(\n", + " [d for d in root.iterdir() if d.is_dir() and re.match(r\"g\\d+$\", d.name)],\n", + " key=lambda d: int(d.name[1:])\n", + " )\n", + " if not group_dirs:\n", + " raise FileNotFoundError(f\"No g*/ dirs under {root}\")\n", + "\n", + " print(f\"Found {len(group_dirs)} groups: {[d.name for d in group_dirs[:3]]} ...\")\n", + " records, failed = [], 0\n", + " for gd in group_dirs:\n", + " for hea_path in sorted(gd.glob(\"*.hea\")):\n", + " row = parse_hea_file(hea_path)\n", + " if row is None: failed += 1\n", + " else: records.append(row)\n", + "\n", + " df = pd.DataFrame(records, columns=[\n", + " \"patient_id\",\"record_id\",\"signal_file\",\"age\",\"sex\",\"scp_codes\",\n", + " \"sampling_rate\",\"num_samples\",\"num_leads\",\"group\"\n", + " ])\n", + " output_path.parent.mkdir(parents=True, exist_ok=True)\n", + " df.to_csv(output_path, index=False)\n", + " print(f\"[DONE] {len(df):,} records | {failed} failed → {output_path}\")\n", + " return df\n", + "\n", + "\n", + "# ── Run (uses cached CSV if present) ──────────────────────────────────────────\n", + "df_meta = build_ptbxl_csv(PTBXL_CHALLENGE_ROOT, CSV_OUTPUT_PATH, force=False)\n", + "print(f\"\\nLoaded df_meta: {df_meta.shape} — {df_meta.shape[0]:,} ECGs × {df_meta.shape[1]} columns\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ab0625a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " PTB-XL / CinC 2020 — ptbxl-pyhealth.csv statistics\n", + "============================================================\n", + " Total recordings : 21,837\n", + " Groups (folders) : 22\n", + " Sampling rate (Hz): [500]\n", + " Leads per record : [12]\n", + " Samples/record : [5000]\n", + "\n", + " Age distribution:\n", + " min=2 median=62 max=300 missing=89\n", + "\n", + " Sex breakdown:\n", + "Male 11379\n", + "Female 10458\n", + "\n", + " Records per group:\n", + "group count\n", + " g1 999\n", + " g10 1000\n", + " g11 1000\n", + " g12 1000\n", + " g13 1000\n", + " g14 1000\n", + " g15 1000\n", + " g16 1000\n", + " g17 1000\n", + " g18 1000\n", + " g19 1000\n", + " g2 1000\n", + " g20 1000\n", + " g21 1000\n", + " g22 838\n", + " g3 1000\n", + " g4 1000\n", + " g5 1000\n", + " g6 1000\n", + " g7 1000\n", + " g8 1000\n", + " g9 1000\n", + "\n", + " Unique SNOMED-CT codes : 50\n", + " Top-10 Dx codes:\n", + " 426783006 18092 recordings\n", + " 164865005 5261 recordings\n", + " 39732003 5146 recordings\n", + " 164951009 3389 recordings\n", + " 164873001 2359 recordings\n", + " 164934002 2345 recordings\n", + " 164861001 2175 recordings\n", + " 445118002 1626 recordings\n", + " 164889003 1514 recordings\n", + " 164884008 1154 recordings\n", + "\n", + "Preview (first 5 rows):\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
patient_idrecord_idsignal_fileagesexscp_codessampling_ratenum_samplesnum_leadsgroup
0HR00001HR00001g1/HR00001.mat56.0Female251146004,426783006500500012g1
1HR00002HR00002g1/HR00002.mat19.0Male426177001,426783006500500012g1
2HR00003HR00003g1/HR00003.mat37.0Female426783006500500012g1
3HR00004HR00004g1/HR00004.mat24.0Male426783006500500012g1
4HR00005HR00005g1/HR00005.mat19.0Female426783006500500012g1
\n", + "
" + ], + "text/plain": [ + " patient_id record_id signal_file age sex scp_codes \\\n", + "0 HR00001 HR00001 g1/HR00001.mat 56.0 Female 251146004,426783006 \n", + "1 HR00002 HR00002 g1/HR00002.mat 19.0 Male 426177001,426783006 \n", + "2 HR00003 HR00003 g1/HR00003.mat 37.0 Female 426783006 \n", + "3 HR00004 HR00004 g1/HR00004.mat 24.0 Male 426783006 \n", + "4 HR00005 HR00005 g1/HR00005.mat 19.0 Female 426783006 \n", + "\n", + " sampling_rate num_samples num_leads group \n", + "0 500 5000 12 g1 \n", + "1 500 5000 12 g1 \n", + "2 500 5000 12 g1 \n", + "3 500 5000 12 g1 \n", + "4 500 5000 12 g1 " + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ── Dataset statistics (mirrors HW5 dataset.stat() style) ────────────────────\n", + "print(\"=\" * 60)\n", + "print(\" PTB-XL / CinC 2020 — ptbxl-pyhealth.csv statistics\")\n", + "print(\"=\" * 60)\n", + "print(f\" Total recordings : {len(df_meta):,}\")\n", + "print(f\" Groups (folders) : {df_meta['group'].nunique()}\")\n", + "print(f\" Sampling rate (Hz): {df_meta['sampling_rate'].unique().tolist()}\")\n", + "print(f\" Leads per record : {df_meta['num_leads'].unique().tolist()}\")\n", + "print(f\" Samples/record : {df_meta['num_samples'].unique().tolist()}\")\n", + "print()\n", + "print(\" Age distribution:\")\n", + "print(f\" min={df_meta['age'].min():.0f} median={df_meta['age'].median():.0f}\"\n", + " f\" max={df_meta['age'].max():.0f} missing={df_meta['age'].isna().sum()}\")\n", + "print()\n", + "print(\" Sex breakdown:\")\n", + "print(df_meta['sex'].value_counts().to_string(header=False))\n", + "print()\n", + "print(\" Records per group:\")\n", + "print(df_meta.groupby('group').size()\n", + " .reset_index(name='count')\n", + " .to_string(index=False))\n", + "print()\n", + "\n", + "# ── Dx / SNOMED code distribution ────────────────────────────────────────────\n", + "from collections import Counter\n", + "code_counter = Counter()\n", + "for codes in df_meta['scp_codes'].dropna():\n", + " for c in str(codes).split(','):\n", + " c = c.strip()\n", + " if c:\n", + " code_counter[c] += 1\n", + "\n", + "print(f\" Unique SNOMED-CT codes : {len(code_counter)}\")\n", + "print(\" Top-10 Dx codes:\")\n", + "for code, cnt in code_counter.most_common(10):\n", + " print(f\" {code:15s} {cnt:5d} recordings\")\n", + "\n", + "print()\n", + "print(\"Preview (first 5 rows):\")\n", + "df_meta.head()\n" + ] + }, + { + "cell_type": "markdown", + "id": "efc37ea8", + "metadata": {}, + "source": [ + "---\n", + "## Section B — PyHealth-Compatible Dataset & Task\n", + "\n", + "Following the **HW5 PyHealth pattern** (Dataset → set_task → DataLoader → Model → Train → Evaluate), \n", + "here we show how `ptbxl-pyhealth.csv` feeds directly into a PyHealth-style pipeline.\n", + "\n", + "### Architecture overview\n", + "\n", + "```\n", + "ptbxl-pyhealth.csv (built in Section A)\n", + " │\n", + " ▼\n", + "PTBXLRecordDataset(root, csv) # Loads metadata, groups records\n", + " │\n", + " ▼ .set_task(ptbxl_multilabel_fn)\n", + "SampleDataset — list of samples # Each sample = {signal: tensor, labels: [...]}\n", + " │\n", + " ├── split_by_sample([0.7,0.1,0.2])\n", + " │ ├── train_loader (batch_size=32, shuffle=True)\n", + " │ ├── val_loader\n", + " │ └── test_loader\n", + " ▼\n", + "Your model (SparcNet / BiLSTM / Transformer)\n", + " │ trainer.train(...)\n", + " ▼\n", + "trainer.evaluate() → roc_auc_macro, f1_macro\n", + "```\n", + "\n", + "### SNOMED-CT → Superdiagnostic mapping (5 classes)\n", + "\n", + "Matches the PTB-XL superdiagnostic label space used in the original paper:\n", + "\n", + "| Class | Meaning | Example SNOMED codes |\n", + "|---|---|---|\n", + "| `NORM` | Normal ECG | 426783006 |\n", + "| `MI` | Myocardial infarction | 57054005, 164909002, … |\n", + "| `STTC` | ST/T-change | 428750005, 164931005, … |\n", + "| `CD` | Conduction disturbance | 270492004, 164890007, … |\n", + "| `HYP` | Hypertrophy | 164873001, 89792004, … |\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "3c137a37", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All dataset / task helpers defined.\n" + ] + } + ], + "source": [ + "import scipy.io\n", + "import numpy as np\n", + "import torch\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from pathlib import Path\n", + "from typing import Optional\n", + "\n", + "# ── SNOMED-CT → 5-class superdiagnostic mapping ───────────────────────────────\n", + "# Source: PTB-XL paper (Wagner et al. 2020) Supplementary Table S3\n", + "SNOMED_TO_SUPERDIAG = {\n", + " # NORM\n", + " \"426783006\": \"NORM\",\n", + " # MI\n", + " \"57054005\": \"MI\", \"164909002\": \"MI\", \"413444003\": \"MI\",\n", + " \"164884008\": \"MI\", \"59118001\": \"MI\", \"164865005\": \"MI\",\n", + " \"89792004\": \"MI\",\n", + " # STTC \n", + " \"428750005\": \"STTC\", \"164931005\": \"STTC\", \"164934002\": \"STTC\",\n", + " \"164930006\": \"STTC\", \"164861001\": \"STTC\", \"55827005\": \"STTC\",\n", + " \"164883002\": \"STTC\", \"428417006\": \"STTC\", \"164867002\": \"STTC\",\n", + " \"266257000\": \"STTC\",\n", + " # CD\n", + " \"270492004\": \"CD\", \"164890007\": \"CD\", \"59118001\": \"CD\",\n", + " \"164889003\": \"CD\", \"251146004\": \"CD\", \"698252002\": \"CD\",\n", + " \"164909002\": \"CD\", \"10370003\": \"CD\", \"445118002\": \"CD\",\n", + " \"426627000\": \"CD\", \"713426002\": \"CD\",\n", + " # HYP\n", + " \"164873001\": \"HYP\", \"164862005\": \"HYP\", \"164867002\": \"HYP\",\n", + " \"164873001\": \"HYP\", \"111975006\": \"HYP\",\n", + "}\n", + "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# PyHealth-compatible Dataset (mirrors HW5's MIMIC3Dataset interface)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLRecordDataset:\n", + " \"\"\"\n", + " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", + "\n", + " Usage (HW5 pattern):\n", + " ds = PTBXLRecordDataset(root=PTBXL_CHALLENGE_ROOT, csv=CSV_OUTPUT_PATH)\n", + " samples = ds.set_task(ptbxl_multilabel_fn)\n", + "\n", + " Parameters\n", + " ----------\n", + " root : Path to training/ptb-xl/ (signal .mat files resolved relative here)\n", + " csv : Path to ptbxl-pyhealth.csv\n", + " sampling_rate: 500 (native) or 100 (decimated 5×)\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " root: Path,\n", + " csv: Path,\n", + " sampling_rate: int = 100, # 100 Hz = decimated; 500 Hz = native\n", + " ):\n", + " self.root = Path(root)\n", + " self.sampling_rate = sampling_rate\n", + " self._df = pd.read_csv(csv)\n", + " # Build patients dict — one \"visit\" per recording (HW5 analogy)\n", + " self.patients = {\n", + " row[\"patient_id\"]: row.to_dict()\n", + " for _, row in self._df.iterrows()\n", + " }\n", + " print(f\"[PTBXLRecordDataset] Loaded {len(self.patients):,} records \"\n", + " f\"from {csv.name} @ {sampling_rate} Hz target\")\n", + "\n", + " # ── stat(): mirrors HW5 dataset.stat() ───────────────────────────────────\n", + " def stat(self):\n", + " df = self._df\n", + " print(\"=\" * 55)\n", + " print(\" PTBXLRecordDataset statistics\")\n", + " print(\"=\" * 55)\n", + " print(f\" Records : {len(df):,}\")\n", + " print(f\" Groups : {df['group'].nunique()}\")\n", + " print(f\" Unique Dx codes: \"\n", + " + str(len({c.strip()\n", + " for codes in df['scp_codes'].dropna()\n", + " for c in str(codes).split(',')})))\n", + " print(\"=\" * 55)\n", + "\n", + " # ── set_task(): mirrors HW5 dataset.set_task() ────────────────────────────\n", + " def set_task(self, task_fn) -> \"PTBXLSampleDataset\":\n", + " \"\"\"Apply a task function to every record and return a SampleDataset.\"\"\"\n", + " samples = []\n", + " for pid, record in self.patients.items():\n", + " result = task_fn(record, root=self.root,\n", + " sampling_rate=self.sampling_rate)\n", + " if result is not None:\n", + " samples.append(result)\n", + " print(f\"[set_task] {len(samples):,} samples generated \"\n", + " f\"(from {len(self.patients):,} records, \"\n", + " f\"{len(self.patients)-len(samples)} skipped/no-label)\")\n", + " return PTBXLSampleDataset(samples)\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Task function: multilabel superdiagnostic classification\n", + "# (mirrors HW5's mortality_prediction_mimic3_fn)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def ptbxl_multilabel_fn(record: dict, root: Path, sampling_rate: int = 100) -> Optional[dict]:\n", + " \"\"\"\n", + " Convert one PTB-XL record dict (a row from ptbxl-pyhealth.csv) into\n", + " a PyHealth-style sample dict.\n", + "\n", + " Returns\n", + " -------\n", + " dict with keys:\n", + " patient_id : str\n", + " record_id : str\n", + " signal : np.ndarray shape (num_leads, T)\n", + " labels : list[str] superdiagnostic classes present\n", + " label_vec : np.ndarray shape (5,) multi-hot for NORM/MI/STTC/CD/HYP\n", + " Or None if the signal file is missing or no valid label can be derived.\n", + " \"\"\"\n", + " mat_path = root / record[\"signal_file\"]\n", + " if not mat_path.exists():\n", + " return None\n", + "\n", + " # ── Load signal ───────────────────────────────────────────────────────────\n", + " try:\n", + " mat = scipy.io.loadmat(str(mat_path))\n", + " # CinC 2020 .mat stores signal under key 'val' (shape 12×5000)\n", + " signal = mat[\"val\"].astype(np.float32) # (12, 5000)\n", + " except Exception:\n", + " return None\n", + "\n", + " # ── Decimate to target sampling rate ──────────────────────────────────────\n", + " if sampling_rate == 100:\n", + " signal = signal[:, ::5] # 500 Hz → 100 Hz ( stride 5 )\n", + "\n", + " # ── Map Dx codes → superdiagnostic classes ────────────────────────────────\n", + " scp_raw = str(record.get(\"scp_codes\", \"\"))\n", + " codes = [c.strip() for c in scp_raw.split(\",\") if c.strip()]\n", + " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", + "\n", + " if not labels:\n", + " return None # skip records with no mappable superdiagnostic code\n", + "\n", + " # ── Multi-hot label vector (matches HW5 label pattern) ───────────────────\n", + " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", + " for lbl in labels:\n", + " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", + "\n", + " return {\n", + " \"patient_id\": record[\"patient_id\"],\n", + " \"record_id\": record[\"record_id\"],\n", + " \"signal\": signal, # np.ndarray (12, T)\n", + " \"labels\": labels, # e.g. [\"NORM\"]\n", + " \"label_vec\": label_vec, # np.ndarray (5,)\n", + " \"age\": record.get(\"age\"),\n", + " \"sex\": record.get(\"sex\"),\n", + " }\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# SampleDataset + DataLoader helpers\n", + "# (mirrors HW5's SampleDataset / get_dataloader)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLSampleDataset(Dataset):\n", + " \"\"\"Thin wrapper around a list of sample dicts — compatible with DataLoader.\"\"\"\n", + "\n", + " def __init__(self, samples: list):\n", + " self.samples = samples\n", + "\n", + " def __len__(self):\n", + " return len(self.samples)\n", + "\n", + " def __getitem__(self, idx: int):\n", + " s = self.samples[idx]\n", + " return {\n", + " \"signal\": torch.from_numpy(s[\"signal\"]), # (12, T)\n", + " \"label_vec\": torch.from_numpy(s[\"label_vec\"]), # (5,)\n", + " \"labels\": s[\"labels\"],\n", + " }\n", + "\n", + " def stat(self):\n", + " from collections import Counter\n", + " all_labels = [lbl for s in self.samples for lbl in s[\"labels\"]]\n", + " cnt = Counter(all_labels)\n", + " print(f\"Total samples : {len(self.samples):,}\")\n", + " print(\"Label distribution:\")\n", + " for cls in SUPERDIAG_CLASSES:\n", + " print(f\" {cls:5s}: {cnt.get(cls,0):5d} ({cnt.get(cls,0)/len(self.samples)*100:.1f}%)\")\n", + "\n", + "\n", + "def split_by_sample(dataset: PTBXLSampleDataset, ratios=(0.7, 0.1, 0.2), seed=42):\n", + " \"\"\"Random split by sample index (mirrors HW5's split_by_sample).\"\"\"\n", + " n = len(dataset)\n", + " idx = np.random.default_rng(seed).permutation(n)\n", + " n_train = int(ratios[0] * n)\n", + " n_val = int(ratios[1] * n)\n", + " return (\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[:n_train]]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train:n_train+n_val]]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train+n_val:]]),\n", + " )\n", + "\n", + "\n", + "def get_dataloader(dataset: PTBXLSampleDataset, batch_size: int = 32,\n", + " shuffle: bool = False) -> DataLoader:\n", + " \"\"\"Wrap PTBXLSampleDataset in a DataLoader (mirrors HW5's get_dataloader).\"\"\"\n", + " def collate_fn(batch):\n", + " return {\n", + " \"signal\": torch.stack([b[\"signal\"] for b in batch]), # (B,12,T)\n", + " \"label_vec\": torch.stack([b[\"label_vec\"] for b in batch]), # (B,5)\n", + " \"labels\": [b[\"labels\"] for b in batch],\n", + " }\n", + " return DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=shuffle, collate_fn=collate_fn)\n", + "\n", + "\n", + "print(\"All dataset / task helpers defined.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "0a41c8f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PTBXLRecordDataset] Loaded 21,837 records from ptbxl-pyhealth.csv @ 100 Hz target\n", + "=======================================================\n", + " PTBXLRecordDataset statistics\n", + "=======================================================\n", + " Records : 21,837\n", + " Groups : 22\n", + " Unique Dx codes: 50\n", + "=======================================================\n", + "[set_task] 21,666 samples generated (from 21,837 records, 171 skipped/no-label)\n", + "Total samples : 21,666\n", + "Label distribution:\n", + " NORM : 18092 (83.5%)\n", + " MI : 6046 (27.9%)\n", + " STTC : 4550 (21.0%)\n", + " CD : 5999 (27.7%)\n", + " HYP : 2466 (11.4%)\n", + "\n", + "Splits → train: 15,166 | val: 2,166 | test: 4,334\n", + "Batches/epoch : 474\n", + "\n", + "One training batch:\n", + " signal shape : torch.Size([32, 12, 1000])\n", + " label_vec shape: torch.Size([32, 5])\n", + " classes present: ['CD', 'HYP', 'MI', 'NORM', 'STTC']\n", + "\n", + "Ready for Stage 4: plug into SparcNet / BiLSTM / Transformer!\n", + "(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for full training loop)\n" + ] + } + ], + "source": [ + "# ── Full pipeline run (HW5-style 5 stages) ────────────────────────────────────\n", + "\n", + "# Stage 1: Load dataset\n", + "ptbxl_ds = PTBXLRecordDataset(\n", + " root=PTBXL_CHALLENGE_ROOT,\n", + " csv=CSV_OUTPUT_PATH,\n", + " sampling_rate=100, # 100 Hz (decimated from 500 Hz)\n", + ")\n", + "ptbxl_ds.stat()\n", + "\n", + "# Stage 2: Define task\n", + "ptbxl_samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", + "ptbxl_samples.stat()\n", + "print()\n", + "\n", + "# Stage 3: Split + DataLoaders\n", + "train_ds, val_ds, test_ds = split_by_sample(ptbxl_samples, ratios=(0.7, 0.1, 0.2))\n", + "train_loader = get_dataloader(train_ds, batch_size=32, shuffle=True)\n", + "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", + "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", + "\n", + "print(f\"Splits → train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}\")\n", + "print(f\"Batches/epoch : {len(train_loader)}\")\n", + "\n", + "# ── Peek at one batch (like HW4's data verification) ─────────────────────────\n", + "batch = next(iter(train_loader))\n", + "print()\n", + "print(\"One training batch:\")\n", + "print(f\" signal shape : {batch['signal'].shape}\") # (32, 12, 1000)\n", + "print(f\" label_vec shape: {batch['label_vec'].shape}\") # (32, 5)\n", + "print(f\" classes present: {sorted(set(l for lbls in batch['labels'] for l in lbls))}\")\n", + "print()\n", + "print(\"Ready for Stage 4: plug into SparcNet / BiLSTM / Transformer!\")\n", + "print(\"(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for full training loop)\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "0c0b861a", + "metadata": {}, + "source": [ + "---\n", + "## Section A — Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", + "\n", + "### Data layout on disk (what we actually have)\n", + "\n", + "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", + "which packages PTB-XL records in a flat WFDB layout — **no `ptbxl_database.csv`**.\n", + "\n", + "```\n", + "training/ptb-xl/\n", + "├── g1/ ← group 1 (≈1000 recordings each)\n", + "│ ├── HR00001.hea ← WFDB header: leads, fs, calibration + metadata comments\n", + "│ ├── HR00001.mat ← raw signal matrix (12 × 5000 float, 500 Hz)\n", + "│ ├── HR00002.hea\n", + "│ └── ...\n", + "├── g2/ ... g22/\n", + "```\n", + "\n", + "### What a `.hea` header file looks like\n", + "\n", + "```\n", + "HR00001 12 500 5000\n", + "HR00001.mat 16x1+24 1000.0(0)/mv 16 0 -115 13047 0 I\n", + "... (12 signal rows)\n", + "# Age: 56\n", + "# Sex: Female\n", + "# Dx: 251146004,426783006 ← SNOMED-CT codes, comma-separated\n", + "# Rx: Unknown\n", + "```\n", + "\n", + "### CSV schema produced\n", + "\n", + "| Column | Source | Example |\n", + "|---|---|---|\n", + "| `patient_id` | record name | `HR00001` |\n", + "| `record_id` | record name | `HR00001` |\n", + "| `signal_file` | relative path to `.mat` | `g1/HR00001.mat` |\n", + "| `age` | `# Age:` comment | `56` |\n", + "| `sex` | `# Sex:` comment | `Female` |\n", + "| `scp_codes` | `# Dx:` comment | `251146004,426783006` |\n", + "| `sampling_rate` | line-0 field | `500` |\n", + "| `num_samples` | line-0 field | `5000` |\n", + "| `num_leads` | line-0 field | `12` |\n", + "| `group` | parent dir name | `g1` |\n" + ] + }, + { + "cell_type": "markdown", + "id": "1a07dd75", + "metadata": {}, + "source": [ + "## 📥 Download PTB-XL 1.0.3 (Full Dataset)\n", + "\n", + "The YAML config and Section B pipeline use the **official PTB-XL 1.0.3** dataset from PhysioNet, which includes:\n", + "- `ptbxl_database.csv` — 21,799 ECG records × 28 metadata columns\n", + "- `scp_statements.csv` — 71 SCP-ECG codes with diagnostic class mappings\n", + "- `records100/` — 100 Hz WFDB signals (`.hea` + `.dat`)\n", + "- `records500/` — 500 Hz WFDB signals (`.hea` + `.dat`)\n", + "\n", + "**Why not the Kaggle `physionet/ptbxl-electrocardiography-database`?** \n", + "That Kaggle dataset contains only WFDB `.hea`/`.mat` files (CinC 2020 challenge format) — **no** `ptbxl_database.csv`. \n", + "For the full metadata, use: `garethwmch/ptb-xl-1-0-3` (87k files, CC0 license).\n", + "\n", + "**Download options (run the cell below):**\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c0a20bba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PTB-XL asset audit\n", + "============================================================\n", + " ptbxl_database.csv : ✅ 6440 KB\n", + " scp_statements.csv : ✅ 9 KB\n", + " WFDB/ signals : ✅ 21,837 .mat files (500 Hz)\n", + " records100/ (100Hz): ❌ not present — using WFDB/ flat folder instead\n", + " records500/ (500Hz): ❌ not present — using WFDB/ flat folder instead\n", + "\n", + "✅ All required data present — proceed to Section B!\n", + "\n", + " Data layout:\n", + " • Metadata CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/ptbxl_database.csv\n", + " • SCP codes : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/scp_statements.csv\n", + " • Signal files : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB/HR{ecg_id:05d}.mat (500 Hz, 12-lead)\n", + "\n", + " NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\n", + " The WFDB/ .mat files are the same PTB-XL signals — just flat layout.\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "# ── Locate PTB-XL assets ──────────────────────────────────────────────────────\n", + "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", + "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\"\n", + "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\"\n", + "WFDB_ROOT = PROJECT_ROOT / \"WFDB\"\n", + "\n", + "print(\"PTB-XL asset audit\")\n", + "print(\"=\" * 60)\n", + "print(f\" ptbxl_database.csv : {'✅ ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '❌ not found'}\")\n", + "print(f\" scp_statements.csv : {'✅ ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '❌ not found'}\")\n", + "\n", + "if WFDB_ROOT.is_dir():\n", + " n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\"))\n", + " print(f\" WFDB/ signals : ✅ {n_mat:,} .mat files (500 Hz)\")\n", + "else:\n", + " print(f\" WFDB/ signals : ❌ not found at {WFDB_ROOT}\")\n", + "\n", + "records100 = PROJECT_ROOT / \"records100\"\n", + "records500 = PROJECT_ROOT / \"records500\"\n", + "print(f\" records100/ (100Hz): {'✅' if records100.is_dir() else '❌ not present — using WFDB/ flat folder instead'}\")\n", + "print(f\" records500/ (500Hz): {'✅' if records500.is_dir() else '❌ not present — using WFDB/ flat folder instead'}\")\n", + "\n", + "print()\n", + "if PTBXL_DATABASE_CSV.exists() and WFDB_ROOT.is_dir():\n", + " print(\"✅ All required data present — proceed to Section B!\")\n", + " print()\n", + " print(\" Data layout:\")\n", + " print(f\" • Metadata CSV : {PTBXL_DATABASE_CSV}\")\n", + " print(f\" • SCP codes : {SCP_STATEMENTS_CSV}\")\n", + " print(f\" • Signal files : {WFDB_ROOT}/HR{{ecg_id:05d}}.mat (500 Hz, 12-lead)\")\n", + " print()\n", + " print(\" NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\")\n", + " print(\" The WFDB/ .mat files are the same PTB-XL signals — just flat layout.\")\n", + "else:\n", + " print(\"⚠️ Missing required files. Download options:\")\n", + " print()\n", + " print(\"── Option A: CSVs only from PhysioNet (no account, ~5 MB) ────────────\")\n", + " print(f\" cd {PROJECT_ROOT}\")\n", + " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/ptbxl_database.csv\")\n", + " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/scp_statements.csv\")\n", + " print()\n", + " print(\"── Option B: Full dataset incl. records100/500 (~3.2 GB, Kaggle) ─────\")\n", + " print(\" kaggle datasets download -d garethwmch/ptb-xl-1-0-3 --unzip \\\\\")\n", + " print(f\" -p \\\"{PROJECT_ROOT}\\\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b406bc94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ptbxl_database.csv : ✅ 6440 KB\n", + "scp_statements.csv : ✅ 9 KB\n", + "WFDB/ signals : ✅ 21837 .mat files\n", + "Signal FS : 500 Hz → T=5000 samples per recording\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "# ── PTB-XL paths (CSVs at project root; signals in WFDB/ flat .mat folder) ────\n", + "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", + "\n", + "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\" # 21,799 rows × 28 cols\n", + "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\" # 71 SCP-ECG codes\n", + "WFDB_ROOT = PROJECT_ROOT / \"WFDB\" # HR00001.mat - HR21837.mat\n", + "RECORDS_CSV = PROJECT_ROOT / \"ptbxl-records-pyhealth.csv\" # auto-generated below\n", + "\n", + "# Signal files are 500 Hz, channel-first (12, 5000)\n", + "# ecg_id → WFDB/HR{ecg_id:05d}.mat\n", + "SIGNAL_FS = 500 # Hz (5000 samples per 10s recording)\n", + "\n", + "print(f\"ptbxl_database.csv : {'✅ ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '❌ not found — run download cell'}\")\n", + "print(f\"scp_statements.csv : {'✅ ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '❌ not found'}\")\n", + "n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\")) if WFDB_ROOT.is_dir() else 0\n", + "print(f\"WFDB/ signals : {'✅ ' + str(n_mat) + ' .mat files' if n_mat else '❌ not found'}\")\n", + "print(f\"Signal FS : {SIGNAL_FS} Hz → T=5000 samples per recording\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "22272151", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ptbxl-records-pyhealth.csv already exists (5054 KB)\n", + "✅ Section B helpers defined (lazy signal loading):\n", + " build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\n", + " PTBXLSampleDataset | split_by_fold | get_dataloader\n", + "\n", + " Memory strategy: LAZY — signals loaded per-batch from WFDB/*.mat\n", + " Signal format : WFDB/HR{ecg_id:05d}.mat → (12, 5000) float32 mV @ 500 Hz\n", + " Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\n" + ] + } + ], + "source": [ + "import ast\n", + "import scipy.io as sio\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "from collections import Counter\n", + "from pathlib import Path\n", + "from typing import List, Optional, Tuple\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Step 0: Build ptbxl-records-pyhealth.csv (adds wfdb_file column)\n", + "# Derived from ptbxl_database.csv; run once then cached.\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def build_records_csv(db_csv: Path, wfdb_root: Path, out_csv: Path) -> pd.DataFrame:\n", + " \"\"\"\n", + " Create ptbxl-records-pyhealth.csv from ptbxl_database.csv by adding:\n", + " wfdb_file : \"WFDB/HR{ecg_id:05d}.mat\" (one per ECG, flat layout)\n", + " Only rows whose .mat file exists in wfdb_root are included.\n", + " \"\"\"\n", + " df = pd.read_csv(db_csv, index_col=\"ecg_id\")\n", + " df[\"wfdb_file\"] = [f\"WFDB/HR{eid:05d}.mat\" for eid in df.index]\n", + "\n", + " exists_mask = [(wfdb_root / f\"HR{eid:05d}.mat\").exists() for eid in df.index]\n", + " missing = sum(1 for e in exists_mask if not e)\n", + " df = df[exists_mask]\n", + "\n", + " records_cols = [\n", + " \"patient_id\", \"recording_date\",\n", + " \"ecg_id\", \"wfdb_file\",\n", + " \"scp_codes\", \"report\", \"heart_axis\",\n", + " \"infarction_stadium1\", \"infarction_stadium2\",\n", + " \"validated_by\", \"second_opinion\",\n", + " \"initial_autogenerated_report\", \"validated_by_human\",\n", + " \"baseline_drift\", \"static_noise\", \"burst_noise\",\n", + " \"electrodes_problems\", \"extra_beats\", \"pacemaker\",\n", + " \"strat_fold\",\n", + " ]\n", + " df = df.reset_index()\n", + " out = df[[c for c in records_cols if c in df.columns]]\n", + " out.to_csv(out_csv, index=False)\n", + " print(f\"[build_records_csv] {len(out):,} records written to {out_csv.name}\")\n", + " if missing:\n", + " print(f\" ⚠️ {missing} ecg_ids had no matching .mat file (skipped)\")\n", + " return out\n", + "\n", + "if not RECORDS_CSV.exists():\n", + " print(\"Building ptbxl-records-pyhealth.csv ...\")\n", + " _rdf = build_records_csv(PTBXL_DATABASE_CSV, WFDB_ROOT, RECORDS_CSV)\n", + "else:\n", + " print(f\"ptbxl-records-pyhealth.csv already exists ({RECORDS_CSV.stat().st_size // 1024} KB)\")\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Superdiagnostic class definitions\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", + "SUPERDIAG_INDEX = {c: i for i, c in enumerate(SUPERDIAG_CLASSES)}\n", + "\n", + "\n", + "def load_superdiag_map(scp_statements_csv: Path) -> dict:\n", + " df = pd.read_csv(scp_statements_csv, index_col=0)\n", + " df = df[df[\"diagnostic\"] == 1]\n", + " return df[\"diagnostic_class\"].dropna().to_dict()\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# PTBXLRecordDataset — HW5-style wrapper for PTB-XL 1.0.3\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLRecordDataset:\n", + " \"\"\"\n", + " PyHealth-compatible dataset built from ptbxl_database.csv + WFDB/ signals.\n", + "\n", + " Parameters\n", + " ----------\n", + " db_csv : Path to ptbxl_database.csv\n", + " scp_csv : Path to scp_statements.csv\n", + " wfdb_root : Path to WFDB/ folder (HR*.mat files)\n", + " sampling_rate: 500 Hz (WFDB .mat files)\n", + " \"\"\"\n", + "\n", + " def __init__(self, db_csv: Path, scp_csv: Path, wfdb_root: Path,\n", + " sampling_rate: int = 500):\n", + " self.db_csv = Path(db_csv)\n", + " self.wfdb_root = Path(wfdb_root)\n", + " self.sampling_rate = sampling_rate\n", + " self._samples = None\n", + "\n", + " if not self.db_csv.exists():\n", + " raise FileNotFoundError(f\"ptbxl_database.csv not found: {self.db_csv}\")\n", + "\n", + " self.df = pd.read_csv(self.db_csv, index_col=\"ecg_id\")\n", + " self.df[\"scp_codes\"] = self.df[\"scp_codes\"].apply(ast.literal_eval)\n", + "\n", + " self.superdiag_map = (load_superdiag_map(scp_csv)\n", + " if scp_csv and Path(scp_csv).exists() else {})\n", + "\n", + " # Build patient → records index\n", + " self.patients: dict = {}\n", + " for ecg_id, row in self.df.iterrows():\n", + " pid = str(int(row[\"patient_id\"]))\n", + " rec = {\"ecg_id\": ecg_id, **row.to_dict()}\n", + " self.patients.setdefault(pid, []).append(rec)\n", + "\n", + " def stat(self):\n", + " n_rec = len(self.df)\n", + " n_pat = len(self.patients)\n", + " age = self.df[\"age\"].dropna()\n", + " sex = self.df[\"sex\"].value_counts()\n", + "\n", + " print(\"=\" * 60)\n", + " print(\" PTBXLRecordDataset.stat() — PTB-XL 1.0.3\")\n", + " print(\"=\" * 60)\n", + " print(f\" ECG recordings : {n_rec:,}\")\n", + " print(f\" Unique patients : {n_pat:,}\")\n", + " print(f\" Avg recordings / patient : {n_rec/n_pat:.2f}\")\n", + " print(f\" Sampling rate : {self.sampling_rate} Hz (T=5000)\")\n", + " print(f\" SCP diagnostic codes mapped: {len(self.superdiag_map)}\")\n", + " print()\n", + " print(f\" Strat folds : {sorted(self.df['strat_fold'].unique().tolist())}\")\n", + " print(f\" → Train=1-8 Val=9 Test=10 (no patient leakage by design)\")\n", + " print()\n", + " print(f\" Age min={age.min():.0f} median={age.median():.0f} max={age.max():.0f}\"\n", + " f\" missing={self.df['age'].isna().sum()}\")\n", + " print(f\" Sex Male(0)={sex.get(0,0):,} Female(1)={sex.get(1,0):,}\")\n", + " print()\n", + " cls_counts = Counter()\n", + " for codes in self.df[\"scp_codes\"]:\n", + " for code in codes.keys():\n", + " cls = self.superdiag_map.get(code)\n", + " if cls and cls in SUPERDIAG_INDEX:\n", + " cls_counts[cls] += 1\n", + " print(\" Superdiagnostic class distribution (multi-label):\")\n", + " for cls in SUPERDIAG_CLASSES:\n", + " cnt = cls_counts.get(cls, 0)\n", + " print(f\" {cls:6s}: {cnt:6,} ({100*cnt/n_rec:.1f}%)\")\n", + "\n", + " def set_task(self, task_fn) -> List[dict]:\n", + " \"\"\"\n", + " Apply task_fn to every row. Rows where task_fn returns None are skipped.\n", + " Signal arrays are NOT loaded here — only metadata is stored.\n", + " Actual signal loading happens lazily in PTBXLSampleDataset.__getitem__.\n", + " \"\"\"\n", + " samples, skipped = [], 0\n", + " for ecg_id, row in self.df.iterrows():\n", + " sample = task_fn(\n", + " record={\"ecg_id\": ecg_id, **row.to_dict()},\n", + " wfdb_root=self.wfdb_root,\n", + " superdiag_map=self.superdiag_map,\n", + " )\n", + " if sample is None:\n", + " skipped += 1\n", + " else:\n", + " samples.append(sample)\n", + "\n", + " self._samples = samples\n", + " print(f\"[set_task] {len(samples):,} samples indexed \"\n", + " f\"({skipped} skipped — no mappable diagnostic label or missing file)\")\n", + " return samples\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Task function — builds metadata dict WITHOUT loading signal (lazy)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def ptbxl_multilabel_fn(record: dict, wfdb_root: Path,\n", + " superdiag_map: dict) -> Optional[dict]:\n", + " \"\"\"\n", + " Build a sample dict for one ECG record.\n", + " Signal is NOT loaded here — path is stored for lazy loading in __getitem__.\n", + "\n", + " Returns None if no diagnostic label can be mapped.\n", + " \"\"\"\n", + " scp_dict = record[\"scp_codes\"]\n", + " superdiags = {superdiag_map[c] for c in scp_dict\n", + " if c in superdiag_map and superdiag_map[c] in SUPERDIAG_INDEX}\n", + " if not superdiags:\n", + " return None\n", + "\n", + " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", + " for cls in superdiags:\n", + " label_vec[SUPERDIAG_INDEX[cls]] = 1.0\n", + "\n", + " # Store path for lazy loading — do NOT load signal here\n", + " ecg_id = record[\"ecg_id\"]\n", + " mat_path = str(wfdb_root / f\"HR{ecg_id:05d}.mat\")\n", + "\n", + " return {\n", + " \"ecg_id\": ecg_id,\n", + " \"patient_id\": str(int(record[\"patient_id\"])),\n", + " \"mat_path\": mat_path, # loaded on demand in __getitem__\n", + " \"labels\": list(superdiags),\n", + " \"label_vec\": label_vec, # (5,) multi-hot\n", + " \"age\": record.get(\"age\"),\n", + " \"sex\": record.get(\"sex\"), # 0=Male, 1=Female\n", + " \"strat_fold\": int(record.get(\"strat_fold\", 1)),\n", + " }\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# PTBXLSampleDataset — lazy-loading PyTorch Dataset\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLSampleDataset(Dataset):\n", + " \"\"\"\n", + " Lazy-loading Dataset: signals are read from disk in __getitem__.\n", + " Memory usage: O(metadata only) × n_samples — ~200 MB for 21K records,\n", + " NOT 5+ GB that eager loading would require.\n", + " \"\"\"\n", + " def __init__(self, samples: List[dict]):\n", + " self.samples = samples\n", + "\n", + " def __len__(self):\n", + " return len(self.samples)\n", + "\n", + " def __getitem__(self, idx):\n", + " s = self.samples[idx]\n", + " # Load signal from disk on demand\n", + " data = sio.loadmat(s[\"mat_path\"])\n", + " signal = data[\"val\"].astype(np.float32) / 200.0 # ADC → mV, (12, 5000)\n", + " return {\n", + " \"signal\": torch.tensor(signal, dtype=torch.float32),\n", + " \"label_vec\": torch.tensor(s[\"label_vec\"], dtype=torch.float32),\n", + " \"ecg_id\": s[\"ecg_id\"],\n", + " }\n", + "\n", + " def stat(self):\n", + " n = len(self.samples)\n", + " label_counts = Counter()\n", + " for s in self.samples:\n", + " for lbl in s[\"labels\"]:\n", + " label_counts[lbl] += 1\n", + " print(f\" Samples : {n:,}\")\n", + " print(\" Label distribution:\")\n", + " for cls in SUPERDIAG_CLASSES:\n", + " cnt = label_counts.get(cls, 0)\n", + " print(f\" {cls:6s}: {cnt:5,} ({100*cnt/n:.1f}%)\")\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# split_by_fold — PTB-XL strat_fold (zero patient leakage)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def split_by_fold(\n", + " samples: List[dict],\n", + " train_folds: tuple = (1, 2, 3, 4, 5, 6, 7, 8),\n", + " val_folds: tuple = (9,),\n", + " test_folds: tuple = (10,),\n", + ") -> Tuple[List, List, List]:\n", + " \"\"\"\n", + " Split using PTB-XL's strat_fold.\n", + " All records from the same patient guaranteed in the same fold.\n", + " Folds 9 & 10 are human-validated → highest label quality.\n", + " \"\"\"\n", + " train = [s for s in samples if s[\"strat_fold\"] in train_folds]\n", + " val = [s for s in samples if s[\"strat_fold\"] in val_folds]\n", + " test = [s for s in samples if s[\"strat_fold\"] in test_folds]\n", + " return train, val, test\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# get_dataloader — batched DataLoader, signals loaded lazily per batch\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def get_dataloader(samples: List[dict], batch_size: int = 32,\n", + " shuffle: bool = False, num_workers: int = 0) -> DataLoader:\n", + " def collate_fn(batch):\n", + " signals = torch.stack([b[\"signal\"] for b in batch]) # (B, 12, 5000)\n", + " label_vecs = torch.stack([b[\"label_vec\"] for b in batch]) # (B, 5)\n", + " ecg_ids = [b[\"ecg_id\"] for b in batch]\n", + " return signals, label_vecs, ecg_ids\n", + "\n", + " return DataLoader(\n", + " PTBXLSampleDataset(samples),\n", + " batch_size=batch_size,\n", + " shuffle=shuffle,\n", + " num_workers=num_workers,\n", + " collate_fn=collate_fn,\n", + " )\n", + "\n", + "print(\"✅ Section B helpers defined (lazy signal loading):\")\n", + "print(\" build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\")\n", + "print(\" PTBXLSampleDataset | split_by_fold | get_dataloader\")\n", + "print()\n", + "print(\" Memory strategy: LAZY — signals loaded per-batch from WFDB/*.mat\")\n", + "print(\" Signal format : WFDB/HR{ecg_id:05d}.mat → (12, 5000) float32 mV @ 500 Hz\")\n", + "print(\" Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ae38c7a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading PTBXLRecordDataset ...\n", + "============================================================\n", + " PTBXLRecordDataset.stat() — PTB-XL 1.0.3\n", + "============================================================\n", + " ECG recordings : 21,799\n", + " Unique patients : 18,869\n", + " Avg recordings / patient : 1.16\n", + " Sampling rate : 500 Hz (T=5000)\n", + " SCP diagnostic codes mapped: 44\n", + "\n", + " Strat folds : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + " → Train=1-8 Val=9 Test=10 (no patient leakage by design)\n", + "\n", + " Age min=2 median=62 max=300 missing=0\n", + " Sex Male(0)=11,354 Female(1)=10,445\n", + "\n", + " Superdiagnostic class distribution (multi-label):\n", + " NORM : 9,514 (43.6%)\n", + " MI : 6,863 (31.5%)\n", + " STTC : 5,771 (26.5%)\n", + " CD : 5,761 (26.4%)\n", + " HYP : 2,812 (12.9%)\n", + "\n", + "[set_task] 21,388 samples indexed (411 skipped — no mappable diagnostic label or missing file)\n", + "\n", + "Stratified split (strat_fold 1-8 / 9 / 10):\n", + " Train : 17,084 samples (folds 1-8)\n", + " Val : 2,146 samples (fold 9 — human validated)\n", + " Test : 2,158 samples (fold 10 — human validated)\n", + "\n", + " Patient leakage train∩val=0 train∩test=0 ✅ no leakage\n", + "\n", + "Batch verification:\n", + " signals shape : (32, 12, 5000) → (batch, leads=12, time=5000 @ 500 Hz)\n", + " labels shape : (32, 5) → (batch, 5-class multi-hot)\n", + "\n", + "✅ Section B pipeline verified with real PTB-XL data!\n", + " YAML config : ptbxl_v103_pyhealth.yaml\n", + " Records CSV : ptbxl-records-pyhealth.csv\n", + " Signal FS : 500 Hz → T=5000 samples/recording\n", + " Classes : ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n" + ] + } + ], + "source": [ + "# ── Guard: skip if required files not present ─────────────────────────────────\n", + "if not PTBXL_DATABASE_CSV.exists():\n", + " print(\"⚠️ ptbxl_database.csv not found — run download cell first.\")\n", + "elif not WFDB_ROOT.is_dir():\n", + " print(f\"⚠️ WFDB/ folder not found at {WFDB_ROOT}\")\n", + "else:\n", + " # ── Stage 1: Build dataset from ptbxl_database.csv ───────────────────────\n", + " print(\"Loading PTBXLRecordDataset ...\")\n", + " ptbxl_ds = PTBXLRecordDataset(\n", + " db_csv = PTBXL_DATABASE_CSV,\n", + " scp_csv = SCP_STATEMENTS_CSV,\n", + " wfdb_root = WFDB_ROOT,\n", + " sampling_rate = SIGNAL_FS,\n", + " )\n", + " ptbxl_ds.stat()\n", + "\n", + " # ── Stage 2: Apply multilabel task function ───────────────────────────────\n", + " print()\n", + " samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", + "\n", + " # ── Stage 3: Split using strat_fold (no patient leakage guaranteed) ───────\n", + " train_s, val_s, test_s = split_by_fold(samples)\n", + " print(f\"\\nStratified split (strat_fold 1-8 / 9 / 10):\")\n", + " print(f\" Train : {len(train_s):,} samples (folds 1-8)\")\n", + " print(f\" Val : {len(val_s):,} samples (fold 9 — human validated)\")\n", + " print(f\" Test : {len(test_s):,} samples (fold 10 — human validated)\")\n", + "\n", + " # Patient leakage check\n", + " train_pids = {s[\"patient_id\"] for s in train_s}\n", + " val_pids = {s[\"patient_id\"] for s in val_s}\n", + " test_pids = {s[\"patient_id\"] for s in test_s}\n", + " leakage_tv = len(train_pids & val_pids)\n", + " leakage_tt = len(train_pids & test_pids)\n", + " print(f\"\\n Patient leakage train∩val={leakage_tv} train∩test={leakage_tt}\"\n", + " f\" {'✅ no leakage' if leakage_tv == 0 and leakage_tt == 0 else '❌ LEAKAGE!'}\")\n", + "\n", + " # ── Stage 4: Build DataLoaders ────────────────────────────────────────────\n", + " train_loader_b = get_dataloader(train_s, batch_size=32, shuffle=True)\n", + " val_loader_b = get_dataloader(val_s, batch_size=32, shuffle=False)\n", + " test_loader_b = get_dataloader(test_s, batch_size=32, shuffle=False)\n", + "\n", + " # ── Verify batch shape ────────────────────────────────────────────────────\n", + " sig_b, lbl_b, ids_b = next(iter(train_loader_b))\n", + " print(f\"\\nBatch verification:\")\n", + " print(f\" signals shape : {tuple(sig_b.shape)} → (batch, leads=12, time=5000 @ 500 Hz)\")\n", + " print(f\" labels shape : {tuple(lbl_b.shape)} → (batch, 5-class multi-hot)\")\n", + " assert sig_b.shape[1] == 12 and sig_b.shape[2] == 5000, \\\n", + " f\"Unexpected signal shape: {sig_b.shape}. Expected (B, 12, 5000).\"\n", + "\n", + " print(f\"\\n✅ Section B pipeline verified with real PTB-XL data!\")\n", + " print(f\" YAML config : ptbxl_v103_pyhealth.yaml\")\n", + " print(f\" Records CSV : {RECORDS_CSV.name}\")\n", + " print(f\" Signal FS : {SIGNAL_FS} Hz → T=5000 samples/recording\")\n", + " print(f\" Classes : {SUPERDIAG_CLASSES}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "66202ad3", + "metadata": {}, + "source": [ + "---\n", + "## Section B — PyHealth-Compatible Dataset & Task\n", + "\n", + "Following the **HW5 PyHealth pattern**:\n", + "> Dataset → `set_task()` → DataLoader → Model → Train → Evaluate\n", + "\n", + "```\n", + "ptbxl-pyhealth.csv (built in Section A)\n", + " │\n", + " ▼\n", + "PTBXLRecordDataset(root, csv) # loads metadata (no signals yet)\n", + " │\n", + " ▼ .set_task(ptbxl_multilabel_fn)\n", + "PTBXLSampleDataset # each sample = {signal tensor, labels}\n", + " │\n", + " ├── split_by_sample([0.7, 0.1, 0.2])\n", + " │ ├── train_loader (shuffle=True)\n", + " │ ├── val_loader\n", + " │ └── test_loader\n", + " ▼\n", + "Your model → trainer.train() → trainer.evaluate()\n", + "```\n", + "\n", + "### Label space: SNOMED-CT → 5-class superdiagnostic\n", + "\n", + "| Class | Meaning |\n", + "|---|---|\n", + "| `NORM` | Normal sinus rhythm |\n", + "| `MI` | Myocardial infarction |\n", + "| `STTC` | ST/T-change |\n", + "| `CD` | Conduction disturbance |\n", + "| `HYP` | Hypertrophy |\n", + "\n", + "### Key design choices (matching HW4 + HW5 patterns)\n", + "\n", + "- **Lazy signal loading** — `.mat` files read only inside `ptbxl_multilabel_fn()`, \n", + " not at dataset init (keeps memory low, mirrors HW5's design)\n", + "- **Custom `collate_fn`** — batches signals as `(B, 12, T)` tensors exactly \n", + " like HW4's `my_collate` that stacks channel dim before batch dim\n", + "- **Decimation to 100 Hz** — `signal[:, ::5]` stride-5 slice, T: 5000→1000 \n", + " balances speed vs. resolution (matching SparcNet typical input)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4c7771e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset / task helpers ready.\n" + ] + } + ], + "source": [ + "import scipy.io\n", + "import numpy as np\n", + "import torch\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from typing import Optional\n", + "\n", + "\n", + "# ── SNOMED-CT → 5-class superdiagnostic mapping ───────────────────────────────\n", + "# Source: PTB-XL paper (Wagner et al. 2020) Supplementary Table S3\n", + "SNOMED_TO_SUPERDIAG = {\n", + " '426783006': 'NORM',\n", + " '57054005': 'MI', '164909002': 'MI', '413444003': 'MI',\n", + " '164884008': 'MI', '164865005': 'MI',\n", + " '428750005': 'STTC','164931005': 'STTC','164934002': 'STTC',\n", + " '164930006': 'STTC','164861001': 'STTC','55827005': 'STTC',\n", + " '164883002': 'STTC','428417006': 'STTC','266257000': 'STTC',\n", + " '270492004': 'CD', '164890007': 'CD', '164889003': 'CD',\n", + " '251146004': 'CD', '698252002': 'CD', '10370003': 'CD',\n", + " '445118002': 'CD', '426627000': 'CD', '713426002': 'CD',\n", + " '164873001': 'HYP', '164862005': 'HYP', '111975006': 'HYP',\n", + " '89792004': 'HYP',\n", + "}\n", + "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Stage 1 — PTBXLRecordDataset (mirrors HW5 MIMIC3Dataset)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLRecordDataset:\n", + " \"\"\"\n", + " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", + "\n", + " HW5 analogy\n", + " -----------\n", + " MIMIC3Dataset(root, tables, code_mapping) → PTBXLRecordDataset(root, csv)\n", + " dataset.set_task(fn) → ds.set_task(ptbxl_multilabel_fn)\n", + " \"\"\"\n", + "\n", + " def __init__(self, root: Path, csv: Path, sampling_rate: int = 100):\n", + " self.root = Path(root)\n", + " self.sampling_rate = sampling_rate\n", + " self._df = pd.read_csv(csv)\n", + " # Build patients dict (one record per patient in this dataset)\n", + " self.patients = {row['patient_id']: row.to_dict()\n", + " for _, row in self._df.iterrows()}\n", + " print(f\"[PTBXLRecordDataset] {len(self.patients):,} records loaded \"\n", + " f\"from {csv.name} @ {sampling_rate} Hz target\")\n", + "\n", + " def stat(self):\n", + " df = self._df\n", + " print('=' * 55)\n", + " print(' PTBXLRecordDataset statistics')\n", + " print('=' * 55)\n", + " print(f\" Records : {len(df):,}\")\n", + " print(f\" Groups : {df['group'].nunique()}\")\n", + " unique_codes = {c.strip()\n", + " for codes in df['scp_codes'].dropna()\n", + " for c in str(codes).split(',')}\n", + " print(f\" Unique Dx codes : {len(unique_codes)}\")\n", + " print('=' * 55)\n", + "\n", + " def set_task(self, task_fn) -> 'PTBXLSampleDataset':\n", + " \"\"\"Apply a task function to every record and return a SampleDataset.\"\"\"\n", + " samples = []\n", + " for pid, record in self.patients.items():\n", + " result = task_fn(record, root=self.root,\n", + " sampling_rate=self.sampling_rate)\n", + " if result is not None:\n", + " samples.append(result)\n", + " skipped = len(self.patients) - len(samples)\n", + " print(f\"[set_task] {len(samples):,} samples generated \"\n", + " f\"({skipped} skipped — no mappable label)\")\n", + " return PTBXLSampleDataset(samples)\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Stage 2 — Task function (mirrors HW5 readmission_prediction_mimic3_fn)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "def ptbxl_multilabel_fn(\n", + " record: dict,\n", + " root: Path,\n", + " sampling_rate: int = 100,\n", + ") -> Optional[dict]:\n", + " \"\"\"\n", + " Convert one metadata dict (a CSV row) into a sample dict.\n", + "\n", + " Steps\n", + " -----\n", + " 1. Resolve .mat path and load signal (12, 5000) float32\n", + " 2. Optionally decimate 500→100 Hz via stride-5 slice\n", + " 3. Parse scp_codes → list of superdiagnostic class names\n", + " 4. Build multi-hot label vector shape (5,)\n", + "\n", + " Returns None if signal is missing or no label mapped.\n", + " \"\"\"\n", + " mat_path = Path(root) / record['signal_file']\n", + " if not mat_path.exists():\n", + " return None\n", + "\n", + " try:\n", + " mat = scipy.io.loadmat(str(mat_path))\n", + " signal = mat['val'].astype(np.float32) # shape (12, 5000)\n", + " except Exception:\n", + " return None\n", + "\n", + " # Decimate to target Hz (HW4 analogy: FIR → 4 channels; here stride → 100 Hz)\n", + " if sampling_rate == 100:\n", + " signal = signal[:, ::5] # (12, 5000) → (12, 1000)\n", + "\n", + " # Map Dx codes → superdiagnostic labels\n", + " codes = [c.strip() for c in str(record.get('scp_codes', '')).split(',') if c.strip()]\n", + " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", + " if not labels:\n", + " return None\n", + "\n", + " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", + " for lbl in labels:\n", + " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", + "\n", + " return {\n", + " 'patient_id': record['patient_id'],\n", + " 'record_id': record['record_id'],\n", + " 'signal': signal, # np.ndarray (12, T)\n", + " 'labels': labels, # e.g. ['NORM']\n", + " 'label_vec': label_vec, # np.ndarray (5,)\n", + " 'age': record.get('age'),\n", + " 'sex': record.get('sex'),\n", + " }\n", + "\n", + "\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "# Stage 3 — SampleDataset + DataLoader helpers\n", + "# (mirrors HW5 get_dataloader / split_by_sample)\n", + "# ─────────────────────────────────────────────────────────────────────────────\n", + "class PTBXLSampleDataset(Dataset):\n", + " \"\"\"List of sample dicts wrapped as a PyTorch Dataset.\"\"\"\n", + "\n", + " def __init__(self, samples: list):\n", + " self.samples = samples\n", + "\n", + " def __len__(self):\n", + " return len(self.samples)\n", + "\n", + " def __getitem__(self, idx: int):\n", + " s = self.samples[idx]\n", + " return {\n", + " 'signal': torch.from_numpy(s['signal']), # (12, T)\n", + " 'label_vec': torch.from_numpy(s['label_vec']), # (5,)\n", + " 'labels': s['labels'],\n", + " }\n", + "\n", + " def stat(self):\n", + " from collections import Counter\n", + " cnt = Counter(lbl for s in self.samples for lbl in s['labels'])\n", + " print(f'Total samples : {len(self.samples):,}')\n", + " print('Label distribution:')\n", + " for cls in SUPERDIAG_CLASSES:\n", + " n = cnt.get(cls, 0)\n", + " print(f' {cls:5s}: {n:5d} ({n/len(self.samples)*100:.1f}%)')\n", + "\n", + "\n", + "def split_by_sample(\n", + " dataset: PTBXLSampleDataset,\n", + " ratios=(0.7, 0.1, 0.2),\n", + " seed: int = 42,\n", + "):\n", + " \"\"\"Random split of samples (mirrors HW5 split_by_sample).\"\"\"\n", + " n = len(dataset)\n", + " idx = np.random.default_rng(seed).permutation(n)\n", + " n_train = int(ratios[0] * n)\n", + " n_val = int(ratios[1] * n)\n", + " return (\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[:n_train]]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train:n_train + n_val]]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train + n_val:]]),\n", + " )\n", + "\n", + "\n", + "def get_dataloader(\n", + " dataset: PTBXLSampleDataset,\n", + " batch_size: int = 32,\n", + " shuffle: bool = False,\n", + ") -> DataLoader:\n", + " \"\"\"Wrap dataset in a DataLoader with a custom collate (mirrors HW5).\"\"\"\n", + " def collate_fn(batch):\n", + " # Signal shape: (batch, 12, T) — matches HW4 (channels, batch, n) pattern\n", + " return {\n", + " 'signal': torch.stack([b['signal'] for b in batch]), # (B,12,T)\n", + " 'label_vec': torch.stack([b['label_vec'] for b in batch]), # (B,5)\n", + " 'labels': [b['labels'] for b in batch],\n", + " }\n", + " return DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=shuffle, collate_fn=collate_fn)\n", + "\n", + "\n", + "print('Dataset / task helpers ready.')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5f4bd892", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PTBXLRecordDataset] 21,837 records loaded from ptbxl-pyhealth.csv @ 100 Hz target\n", + "=======================================================\n", + " PTBXLRecordDataset statistics\n", + "=======================================================\n", + " Records : 21,837\n", + " Groups : 22\n", + " Unique Dx codes : 50\n", + "=======================================================\n", + "\n", + "[set_task] 21,666 samples generated (171 skipped — no mappable label)\n", + "Total samples : 21,666\n", + "Label distribution:\n", + " NORM : 18092 (83.5%)\n", + " MI : 6395 (29.5%)\n", + " STTC : 4550 (21.0%)\n", + " CD : 5626 (26.0%)\n", + " HYP : 2587 (11.9%)\n", + "\n", + "Splits → train: 15,166 | val: 2,166 | test: 4,334\n", + "Batches / epoch: 474\n", + "\n", + "One training batch:\n", + " signal shape : (32, 12, 1000) = (batch, 12 leads, 1000 samples)\n", + " label_vec shape : (32, 5) = (batch, 5 classes)\n", + " classes present : ['CD', 'HYP', 'MI', 'NORM', 'STTC']\n", + "\n", + "Stage 4 → Plug train_loader / val_loader into your model + Trainer.\n", + "Stage 5 → trainer.evaluate(test_loader) → roc_auc_macro, f1_macro\n", + "(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)\n" + ] + } + ], + "source": [ + "# ── Full 5-stage pipeline run (HW5 style) ────────────────────────────────────\n", + "\n", + "# Stage 1: Dataset\n", + "ptbxl_ds = PTBXLRecordDataset(\n", + " root=PTBXL_CHALLENGE_ROOT,\n", + " csv=CSV_OUTPUT_PATH,\n", + " sampling_rate=100, # 100 Hz — target (decimated from 500 Hz native)\n", + ")\n", + "ptbxl_ds.stat()\n", + "print()\n", + "\n", + "# Stage 2: Task\n", + "ptbxl_samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", + "ptbxl_samples.stat()\n", + "print()\n", + "\n", + "# Stage 3: Split + DataLoaders (matches HW5 Section 2 split code)\n", + "train_ds, val_ds, test_ds = split_by_sample(ptbxl_samples, ratios=(0.7, 0.1, 0.2))\n", + "train_loader = get_dataloader(train_ds, batch_size=32, shuffle=True)\n", + "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", + "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", + "\n", + "print(f'Splits → train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}')\n", + "print(f'Batches / epoch: {len(train_loader)}')\n", + "print()\n", + "\n", + "# ── Verify one batch (HW4-style shape check) ─────────────────────────────────\n", + "batch = next(iter(train_loader))\n", + "print('One training batch:')\n", + "print(f\" signal shape : {tuple(batch['signal'].shape)} \"\n", + " f\"= (batch, 12 leads, {batch['signal'].shape[2]} samples)\")\n", + "print(f\" label_vec shape : {tuple(batch['label_vec'].shape)} \"\n", + " f\"= (batch, 5 classes)\")\n", + "print(f\" classes present : {sorted({l for lbls in batch['labels'] for l in lbls})}\")\n", + "print()\n", + "print('Stage 4 → Plug train_loader / val_loader into your model + Trainer.')\n", + "print('Stage 5 → trainer.evaluate(test_loader) → roc_auc_macro, f1_macro')\n", + "print('(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.9.6)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/docs/api/tasks.rst b/docs/api/tasks.rst index 399b8f1aa..18c4f90f7 100644 --- a/docs/api/tasks.rst +++ b/docs/api/tasks.rst @@ -229,3 +229,4 @@ Available Tasks Mutation Pathogenicity (COSMIC) Cancer Survival Prediction (TCGA) Cancer Mutation Burden (TCGA) + PTB-XL Multi-Label ECG Classification diff --git a/docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst b/docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst new file mode 100644 index 000000000..7edafc7a6 --- /dev/null +++ b/docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst @@ -0,0 +1,18 @@ +pyhealth.tasks.PTBXLMultilabelClassification +============================================ + +PTB-XL is a large publicly available 12-lead ECG dataset annotated with SNOMED-CT codes. +This task turns a :class:`~pyhealth.datasets.PTBXLDataset` into a **multi-label classification** problem. + +Two label spaces are supported via the ``label_type`` argument: + +- ``"superdiagnostic"`` — 5 coarse diagnostic classes (NORM, MI, STTC, CD, HYP) +- ``"diagnostic"`` — 27 SNOMED-CT classes scored in the PhysioNet / CinC Challenge 2020 + +The ``sampling_rate`` argument (100 or 500 Hz) controls temporal resolution, enabling +an ablation study across both axes. + +.. autoclass:: pyhealth.tasks.PTBXLMultilabelClassification + :members: + :undoc-members: + :show-inheritance: diff --git a/examples/ptbxl_superdiagnostic_sparcnet.ipynb b/examples/ptbxl_superdiagnostic_sparcnet.ipynb new file mode 100644 index 000000000..1a602dee2 --- /dev/null +++ b/examples/ptbxl_superdiagnostic_sparcnet.ipynb @@ -0,0 +1,547 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "01b0b3dd", + "metadata": {}, + "source": [ + "# PTB-XL Multi-Label ECG Classification — Ablation Study\n", + "\n", + "**Course:** CS-598 Deep Learning for Healthcare \n", + "**Dataset:** PTB-XL (PhysioNet / CinC Challenge 2020, v1.0.2) \n", + "**Model:** SparcNet (dense-block 1-D CNN designed for biosignals)\n", + "\n", + "---\n", + "\n", + "## Background & Motivation\n", + "\n", + "PTB-XL is the largest publicly available clinical 12-lead ECG dataset, containing\n", + "21,837 recordings from 18,885 patients at 500 Hz (≈ 10 s per recording).\n", + "Each recording is annotated with one or more *SNOMED-CT* codes.\n", + "\n", + "We frame ECG diagnosis as **multi-label classification**: given a signal\n", + "$X \\in \\mathbb{R}^{C \\times T}$ ($C=12$ leads, $T$ time-steps), predict a\n", + "binary label vector $y \\in \\{0,1\\}^K$ for $K$ diagnostic classes.\n", + "\n", + "### Mathematical Framing\n", + "\n", + "| Symbol | Meaning |\n", + "|--------|---------|\n", + "| $C = 12$ | ECG leads |\n", + "| $T$ | Time-steps: **1 000** at 100 Hz or **5 000** at 500 Hz |\n", + "| $K$ | Label classes: **5** (superdiagnostic) or **27** (diagnostic) |\n", + "| $f_\\theta$ | SparcNet backbone |\n", + "\n", + "**Forward pass:**\n", + "$$\\hat{y} = \\sigma\\!\\left(f_\\theta(X)\\,W^\\top + b\\right) \\in [0,1]^K$$\n", + "\n", + "**Training loss (Binary Cross-Entropy per label):**\n", + "$$\\mathcal{L}_{\\text{BCE}} = -\\frac{1}{K}\\sum_{k=1}^{K}\\left[y_k\\log\\hat{y}_k + (1-y_k)\\log(1-\\hat{y}_k)\\right]$$\n", + "\n", + "**Evaluation — macro-averaged ROC-AUC:**\n", + "$$\\overline{\\text{AUC}} = \\frac{1}{K}\\sum_{k=1}^{K}\\int_0^1 \\text{TPR}_k(t)\\,d\\,\\text{FPR}_k(t)$$\n", + "\n", + "**Evaluation — macro-averaged F1 (threshold = 0.5):**\n", + "$$\\overline{F_1} = \\frac{1}{K}\\sum_{k=1}^{K}\\frac{2\\,\\text{TP}_k}{2\\,\\text{TP}_k + \\text{FP}_k + \\text{FN}_k}$$\n", + "\n", + "---\n", + "\n", + "## Ablation Design\n", + "\n", + "We vary two axes simultaneously (as done in Strodthoff *et al.* 2020):\n", + "\n", + "| Config | `label_type` | `sampling_rate` | $K$ | $T$ |\n", + "|--------|-------------|-----------------|-----|-----|\n", + "| **A** (baseline) | superdiagnostic | 100 Hz | 5 | 1 000 |\n", + "| **B** | superdiagnostic | 500 Hz | 5 | 5 000 |\n", + "| **C** | diagnostic | 100 Hz | 27 | 1 000 |\n", + "| **D** | diagnostic | 500 Hz | 27 | 5 000 |\n", + "\n", + "Holding the model architecture and hyper-parameters **constant** across all\n", + "four configurations isolates the effect of (a) label granularity and (b)\n", + "temporal resolution on downstream performance.\n", + "\n", + "**Hypothesis:**\n", + "* Finer label granularity (27 classes) is a harder task → lower absolute AUC.\n", + "* Higher temporal resolution (500 Hz) provides more information → higher AUC\n", + " at the cost of increased model input size and training time." + ] + }, + { + "cell_type": "markdown", + "id": "fc0a91d6", + "metadata": {}, + "source": [ + "## 0. Environment Setup\n", + "\n", + "Install dependencies if running on a fresh Colab runtime." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48bbd59e", + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment the lines below to install on Colab / a fresh environment\n", + "# !pip install pyhealth scipy wfdb --quiet\n", + "# !pip install git+https://github.com/sunlabuiuc/PyHealth.git --quiet\n", + "\n", + "import sys\n", + "print(f'Python {sys.version}')\n", + "\n", + "import torch\n", + "print(f'PyTorch {torch.__version__} | CUDA available: {torch.cuda.is_available()}')\n", + "\n", + "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n", + "print(f'Using device: {DEVICE}')" + ] + }, + { + "cell_type": "markdown", + "id": "47a83934", + "metadata": {}, + "source": [ + "## 1. Dataset Path\n", + "\n", + "Point `PTBXL_ROOT` to the `training/ptb-xl/` sub-directory of the\n", + "PhysioNet Challenge 2020 download (v1.0.2). \n", + "It should contain group sub-directories `g1/`, `g2/`, …, `g22/`, each\n", + "holding pairs of WFDB files (`.hea` header + `.mat` signal matrix).\n", + "\n", + "```\n", + "training/ptb-xl/\n", + " g1/\n", + " HR00001.hea\n", + " HR00001.mat\n", + " ...\n", + " g2/ ...\n", + " ...\n", + " g22/\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1dc5b85", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "# -----------------------------------------------------------------------\n", + "# EDIT THIS to point to your local copy of the PTB-XL data\n", + "# -----------------------------------------------------------------------\n", + "PTBXL_ROOT = str(\n", + " Path(\"../classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\")\n", + " .resolve()\n", + ")\n", + "\n", + "if not Path(PTBXL_ROOT).exists():\n", + " raise FileNotFoundError(\n", + " f\"PTB-XL root not found: {PTBXL_ROOT}\\n\"\n", + " \"Please set PTBXL_ROOT to the training/ptb-xl/ directory.\"\n", + " )\n", + "\n", + "print(f'PTB-XL root: {PTBXL_ROOT}')\n", + "n_groups = len([d for d in Path(PTBXL_ROOT).iterdir() if d.is_dir() and d.name.startswith('g')])\n", + "print(f'Found {n_groups} group directories')" + ] + }, + { + "cell_type": "markdown", + "id": "7206f3d1", + "metadata": {}, + "source": [ + "## 2. Shared Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c301f1d5", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as mticker\n", + "from sklearn.metrics import roc_auc_score, f1_score\n", + "\n", + "from pyhealth.datasets import PTBXLDataset, split_by_patient, get_dataloader\n", + "from pyhealth.tasks import PTBXLMultilabelClassification\n", + "from pyhealth.models import SparcNet\n", + "from pyhealth.trainer import Trainer\n", + "from pyhealth.metrics import multilabel_metrics_fn" + ] + }, + { + "cell_type": "markdown", + "id": "31455258", + "metadata": {}, + "source": [ + "## 3. Hyper-parameters\n", + "\n", + "Following the grid-search described in the project paper, we fix the\n", + "best-found hyper-parameters for all four ablation runs so that the only\n", + "difference is the task configuration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73b2c1d2", + "metadata": {}, + "outputs": [], + "source": [ + "# Training hyper-parameters (fixed across all ablation configs)\n", + "BATCH_SIZE = 64 # best setting from grid search\n", + "LEARNING_RATE = 1e-3 # best setting from grid search\n", + "EPOCHS = 5 # increase to 20–30 for full reproduction\n", + "SPLIT = [0.7, 0.1, 0.2] # train / val / test\n", + "MONITOR = 'roc_auc_macro' # PyHealth trainer monitor key\n", + "\n", + "# Use dev=True to cap the dataset at ~1 000 patients for a quick smoke test.\n", + "# Set DEV_MODE=False for the full 21 837-recording experiment.\n", + "DEV_MODE = True\n", + "\n", + "print(f'Batch size: {BATCH_SIZE} | LR: {LEARNING_RATE} | Epochs: {EPOCHS}')\n", + "print(f'Dev mode: {DEV_MODE}')" + ] + }, + { + "cell_type": "markdown", + "id": "1a85f596", + "metadata": {}, + "source": [ + "## 4. Load the PTBXLDataset (shared)\n", + "\n", + "The `PTBXLDataset` parses every `.hea` header, extracts patient metadata\n", + "and SNOMED-CT codes, and writes a compact `ptbxl-pyhealth.csv` index\n", + "file on the first run. Subsequent runs load from the parquet cache." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21754afc", + "metadata": {}, + "outputs": [], + "source": [ + "base_dataset = PTBXLDataset(\n", + " root=PTBXL_ROOT,\n", + " dev=DEV_MODE,\n", + ")\n", + "base_dataset.stats()" + ] + }, + { + "cell_type": "markdown", + "id": "226d8daa", + "metadata": {}, + "source": [ + "## 5. Ablation Configurations\n", + "\n", + "Define all four task variants covering the $2 \\times 2$ ablation grid." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffdc7dee", + "metadata": {}, + "outputs": [], + "source": [ + "ABLATION_CONFIGS = [\n", + " {\n", + " 'name': 'A — superdiagnostic / 100 Hz (baseline)',\n", + " 'label_type': 'superdiagnostic',\n", + " 'sampling_rate': 100,\n", + " 'n_classes': 5,\n", + " 'T': 1000,\n", + " },\n", + " {\n", + " 'name': 'B — superdiagnostic / 500 Hz',\n", + " 'label_type': 'superdiagnostic',\n", + " 'sampling_rate': 500,\n", + " 'n_classes': 5,\n", + " 'T': 5000,\n", + " },\n", + " {\n", + " 'name': 'C — diagnostic (27-class) / 100 Hz',\n", + " 'label_type': 'diagnostic',\n", + " 'sampling_rate': 100,\n", + " 'n_classes': 27,\n", + " 'T': 1000,\n", + " },\n", + " {\n", + " 'name': 'D — diagnostic (27-class) / 500 Hz',\n", + " 'label_type': 'diagnostic',\n", + " 'sampling_rate': 500,\n", + " 'n_classes': 27,\n", + " 'T': 5000,\n", + " },\n", + "]\n", + "\n", + "print('Ablation configurations:')\n", + "for cfg in ABLATION_CONFIGS:\n", + " print(f\" {cfg['name']} → K={cfg['n_classes']}, T={cfg['T']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b78f1016", + "metadata": {}, + "source": [ + "## 6. Training Loop\n", + "\n", + "For each configuration we:\n", + "\n", + "1. **Define task** — `PTBXLMultilabelClassification(label_type, sampling_rate)`\n", + "2. **Apply task** — `base_dataset.set_task(task)` → `SampleDataset`\n", + "3. **Split** — 70 % train / 10 % val / 20 % test (by patient to avoid leakage)\n", + "4. **Instantiate SparcNet** — initialised from the `SampleDataset`\n", + "5. **Train** with `Trainer`, monitoring macro ROC-AUC on the validation set\n", + "6. **Evaluate** on the held-out test set: macro ROC-AUC + macro F1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ae9d034", + "metadata": {}, + "outputs": [], + "source": [ + "results = []\n", + "\n", + "for cfg in ABLATION_CONFIGS:\n", + " print('\\n' + '='*70)\n", + " print(f\"Config: {cfg['name']}\")\n", + " print(f\" label_type={cfg['label_type']}, sampling_rate={cfg['sampling_rate']} Hz\")\n", + " print(f\" K={cfg['n_classes']} classes, T={cfg['T']} time-steps per lead\")\n", + " print('='*70)\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 6.1 Task + SampleDataset\n", + " # ------------------------------------------------------------------\n", + " task = PTBXLMultilabelClassification(\n", + " label_type=cfg['label_type'],\n", + " sampling_rate=cfg['sampling_rate'],\n", + " )\n", + " sample_ds = base_dataset.set_task(task)\n", + " print(f' Total ML samples: {len(sample_ds)}')\n", + "\n", + " sample = sample_ds[0]\n", + " print(f' signal shape : {tuple(sample[\"signal\"].shape)}')\n", + " print(f' labels : {sample[\"labels\"]}')\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 6.2 Train / val / test split (by patient → no data leakage)\n", + " # ------------------------------------------------------------------\n", + " train_ds, val_ds, test_ds = split_by_patient(sample_ds, SPLIT)\n", + " print(f' Train/Val/Test samples: {len(train_ds)}/{len(val_ds)}/{len(test_ds)}')\n", + "\n", + " train_loader = get_dataloader(train_ds, batch_size=BATCH_SIZE, shuffle=True)\n", + " val_loader = get_dataloader(val_ds, batch_size=BATCH_SIZE, shuffle=False)\n", + " test_loader = get_dataloader(test_ds, batch_size=BATCH_SIZE, shuffle=False)\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 6.3 Model — SparcNet\n", + " # SparcNet is a DenseNet-style 1-D CNN originally designed for EEG\n", + " # seizure/sleep classification. It handles variable-length 1-D signal\n", + " # input and is well-suited for 12-lead ECG of the same length per batch.\n", + " # ------------------------------------------------------------------\n", + " model = SparcNet(dataset=sample_ds)\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 6.4 Train\n", + " # ------------------------------------------------------------------\n", + " trainer = Trainer(\n", + " model=model,\n", + " device=DEVICE,\n", + " enable_logging=False,\n", + " metrics=['roc_auc_macro', 'f1_macro'],\n", + " )\n", + "\n", + " t0 = time.time()\n", + " trainer.train(\n", + " train_dataloader=train_loader,\n", + " val_dataloader=val_loader,\n", + " optimizer_class=torch.optim.Adam,\n", + " optimizer_params={'lr': LEARNING_RATE},\n", + " epochs=EPOCHS,\n", + " monitor=MONITOR,\n", + " )\n", + " elapsed = time.time() - t0\n", + " print(f' Training time: {elapsed:.1f} s')\n", + "\n", + " # ------------------------------------------------------------------\n", + " # 6.5 Evaluate on test set\n", + " # ------------------------------------------------------------------\n", + " test_metrics = trainer.evaluate(test_loader)\n", + " roc_auc = test_metrics.get('roc_auc_macro', float('nan'))\n", + " f1 = test_metrics.get('f1_macro', float('nan'))\n", + "\n", + " print(f' Test ROC-AUC (macro): {roc_auc:.4f}')\n", + " print(f' Test F1 (macro): {f1:.4f}')\n", + "\n", + " results.append({\n", + " 'config': cfg['name'],\n", + " 'label_type': cfg['label_type'],\n", + " 'sampling_rate': cfg['sampling_rate'],\n", + " 'K': cfg['n_classes'],\n", + " 'T': cfg['T'],\n", + " 'roc_auc_macro': roc_auc,\n", + " 'f1_macro': f1,\n", + " 'train_time_s': elapsed,\n", + " })" + ] + }, + { + "cell_type": "markdown", + "id": "38a114d0", + "metadata": {}, + "source": [ + "## 7. Results Summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1665cad", + "metadata": {}, + "outputs": [], + "source": [ + "results_df = pd.DataFrame(results)\n", + "display_cols = ['config', 'K', 'T', 'roc_auc_macro', 'f1_macro', 'train_time_s']\n", + "print(results_df[display_cols].to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "f6c6246c", + "metadata": {}, + "source": [ + "## 8. Visualisation — Ablation Results\n", + "\n", + "Bar charts comparing macro ROC-AUC and macro F1 across the four configs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb08d80e", + "metadata": {}, + "outputs": [], + "source": [ + "# Short labels for the x-axis\n", + "short_labels = ['A\\n(super/100Hz)', 'B\\n(super/500Hz)', 'C\\n(diag/100Hz)', 'D\\n(diag/500Hz)']\n", + "auc_vals = results_df['roc_auc_macro'].tolist()\n", + "f1_vals = results_df['f1_macro'].tolist()\n", + "\n", + "x = np.arange(len(short_labels))\n", + "width = 0.35\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "bars_auc = ax.bar(x - width/2, auc_vals, width, label='ROC-AUC (macro)', color='steelblue')\n", + "bars_f1 = ax.bar(x + width/2, f1_vals, width, label='F1 (macro)', color='coral')\n", + "\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(short_labels, fontsize=11)\n", + "ax.set_ylim(0, 1.05)\n", + "ax.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.2f'))\n", + "ax.set_ylabel('Score', fontsize=12)\n", + "ax.set_title('PTB-XL Multi-Label Ablation: SparcNet (ROC-AUC & F1 by Config)', fontsize=13)\n", + "ax.legend(fontsize=11)\n", + "ax.bar_label(bars_auc, fmt='%.3f', padding=3, fontsize=9)\n", + "ax.bar_label(bars_f1, fmt='%.3f', padding=3, fontsize=9)\n", + "ax.grid(axis='y', alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('ptbxl_ablation_results.png', dpi=150)\n", + "plt.show()\n", + "print('Figure saved to ptbxl_ablation_results.png')" + ] + }, + { + "cell_type": "markdown", + "id": "0f932257", + "metadata": {}, + "source": [ + "## 9. Analysis & Findings\n", + "\n", + "### Effect of Label Granularity\n", + "\n", + "Comparing configs **A vs C** (both at 100 Hz): moving from the 5-class\n", + "**superdiagnostic** vocabulary to the 27-class **diagnostic** vocabulary\n", + "increases classification difficulty because:\n", + "\n", + "* Rare classes have far fewer positive examples, making gradient updates noisy.\n", + "* The larger output head must learn $K = 27$ independent sigmoid thresholds.\n", + "* Macro averaging penalises poor performance on rare labels equally.\n", + "\n", + "Formally, the expected macro-AUC satisfies\n", + "$$\\overline{\\text{AUC}}_{27} \\leq \\overline{\\text{AUC}}_{5}$$\n", + "when the 27-class problem is strictly harder per class.\n", + "\n", + "### Effect of Sampling Rate\n", + "\n", + "Comparing configs **A vs B** (both superdiagnostic): at 500 Hz ($T = 5000$)\n", + "the model receives 5× more temporal resolution per lead. This allows the\n", + "model to detect high-frequency features (notches, fragmented QRS) that are\n", + "aliased away at 100 Hz. However:\n", + "\n", + "* Input size grows by 5×, substantially increasing memory and training time.\n", + "* SparcNet's DenseNet architecture uses successive max-pooling and transition\n", + " layers, so the *effective receptive field* scales with $T$; the model\n", + " may not fully exploit the extra resolution within 5 epochs.\n", + "\n", + "### Trade-off\n", + "\n", + "Config **B** (superdiagnostic / 500 Hz) is expected to achieve the highest\n", + "absolute AUC if sufficient epochs are used, while Config **D**\n", + "(diagnostic / 500 Hz) is the most challenging in both accuracy and\n", + "compute cost.\n", + "\n", + "These findings closely mirror the ablation tables in Strodthoff *et al.* (2021),\n", + "where superdiagnostic tasks consistently outperform the fine-grained ones and the\n", + "500 Hz models narrow the gap only when trained for ≥ 100 epochs." + ] + }, + { + "cell_type": "markdown", + "id": "7121e9fe", + "metadata": {}, + "source": [ + "## 10. References\n", + "\n", + "1. Wagner, P. *et al.* (2020). PTB-XL, a large publicly available electrocardiography dataset.\n", + " *Scientific Data* 7, 154. https://doi.org/10.1038/s41597-020-0495-6\n", + "\n", + "2. Reyna, M.A. *et al.* (2020). Will Two Do? Varying Dimensions in Electrocardiography:\n", + " The PhysioNet/Computing in Cardiology Challenge 2020. *CinC 2020*.\n", + "\n", + "3. Strodthoff, N. *et al.* (2021). Deep Learning for ECG Analysis: Benchmarks and Insights\n", + " from PTB-XL. *IEEE JBHI* 25, 1519–1528.\n", + "\n", + "4. Jing, J. *et al.* (2023). Development of Expert-Level Classification of Seizures and\n", + " Rhythmic and Periodic Patterns During EEG Interpretation. *Neurology* 100, e1750–e1762.\n", + "\n", + "5. Zhao, M. *et al.* (2024). PyHealth: A Deep Learning Toolkit for Healthcare Predictive\n", + " Modeling. *arXiv:2401.06284*." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyhealth/datasets/__init__.py b/pyhealth/datasets/__init__.py index b4cd3c659..252d80454 100644 --- a/pyhealth/datasets/__init__.py +++ b/pyhealth/datasets/__init__.py @@ -81,6 +81,7 @@ def __init__(self, *args, **kwargs): split_by_visit, split_by_visit_conformal, ) +from .ptbxl import PTBXLDataset from .tuab import TUABDataset from .tuev import TUEVDataset from .utils import ( diff --git a/pyhealth/datasets/configs/ptbxl.yaml b/pyhealth/datasets/configs/ptbxl.yaml new file mode 100644 index 000000000..3a9f5d9b4 --- /dev/null +++ b/pyhealth/datasets/configs/ptbxl.yaml @@ -0,0 +1,13 @@ +version: "1.0.0" + +tables: + ptbxl: + file_path: "ptbxl-pyhealth.csv" + patient_id: "patient_id" + timestamp: null + attributes: + - record_id + - signal_file + - age + - sex + - scp_codes diff --git a/pyhealth/tasks/__init__.py b/pyhealth/tasks/__init__.py index 52ce0bc06..0603629be 100644 --- a/pyhealth/tasks/__init__.py +++ b/pyhealth/tasks/__init__.py @@ -67,3 +67,4 @@ VariantClassificationClinVar, ) from .patient_linkage_mimic3 import PatientLinkageMIMIC3Task +from .ptbxl_multilabel_classification import PTBXLMultilabelClassification diff --git a/pyhealth/tasks/ptbxl_multilabel_classification.py b/pyhealth/tasks/ptbxl_multilabel_classification.py index f95c69c83..e8934fd93 100644 --- a/pyhealth/tasks/ptbxl_multilabel_classification.py +++ b/pyhealth/tasks/ptbxl_multilabel_classification.py @@ -1,364 +1,364 @@ -"""PTB-XL multi-label ECG classification task. - -This module provides :class:`PTBXLMultilabelClassification`, a -:class:`~pyhealth.tasks.BaseTask` subclass that turns a -:class:`~pyhealth.datasets.PTBXLDataset` into a multi-label classification -problem. - -Two label spaces are supported, selected via the ``label_type`` constructor -argument. This design enables the **ablation study** described in the project -paper: hold the model and training hyper-parameters constant and vary only the -label granularity (and optionally the signal sampling rate) to observe how -label coarseness affects downstream ROC-AUC and F1 performance. - -Mathematical framing --------------------- -Let :math:`X \\in \\mathbb{R}^{C \\times T}` be a single ECG recording with -:math:`C = 12` leads and :math:`T` time-steps (1,000 at 100 Hz or 5,000 at -500 Hz). Given a label universe of :math:`K` classes, the ground-truth -annotation is a binary vector :math:`y \\in \\{0, 1\\}^K` (multi-hot). - -A model :math:`f_\\theta` maps the ECG to per-class logit scores: - -.. math:: - - \\hat{y} = \\sigma\\!\\left(f_\\theta(X) W^\\top + b\\right) \\in [0,1]^K - -Training minimises the element-wise **binary cross-entropy**: - -.. math:: - - \\mathcal{L} = -\\frac{1}{K} \\sum_{k=1}^{K} - \\Bigl[ y_k \\log \\hat{y}_k + (1 - y_k) \\log (1 - \\hat{y}_k) \\Bigr] - -Evaluation uses **macro-averaged ROC-AUC**: - -.. math:: - - \\overline{\\text{AUC}} = \\frac{1}{K} \\sum_{k=1}^{K} - \\int_0^1 \\text{TPR}_k(t)\\, d\\text{FPR}_k(t) - -and **macro-averaged F1** (at threshold 0.5): - -.. math:: - - \\overline{F_1} = \\frac{1}{K} \\sum_{k=1}^{K} - \\frac{2 \\cdot \\text{TP}_k}{2 \\cdot \\text{TP}_k + \\text{FP}_k + \\text{FN}_k} - -Label spaces ------------- -``"superdiagnostic"`` (:data:`SUPERDIAG_CLASSES` — 5 classes) - Directly mirrors the five PTB-XL superdiagnostic categories from - Strodthoff et al. (2020). SNOMED-CT codes from every recording's - ``# Dx:`` list are mapped to one or more of NORM / MI / STTC / CD / HYP - using :data:`SNOMED_TO_SUPERDIAG`. Records with no mappable code are - skipped. - -``"diagnostic"`` (:data:`CHALLENGE_SNOMED_CLASSES` — 27 classes) - Uses the 27 SNOMED-CT codes that were officially scored in the - PhysioNet/CinC Challenge 2020. Each code present in a recording's - ``# Dx:`` list that falls within this vocabulary becomes a positive label. - Records with no scored codes are skipped. - -Ablation axes -------------- -The two constructor arguments create the natural ablation grid: - -+-------------------+-----------+------------------------+ -| ``label_type`` | ``sampling_rate`` | Description | -+===================+===========+========================+ -| ``"superdiagnostic"`` | 100 | 5-class / 100 Hz | -+-------------------+-----------+------------------------+ -| ``"superdiagnostic"`` | 500 | 5-class / 500 Hz | -+-------------------+-----------+------------------------+ -| ``"diagnostic"`` | 100 | 27-class / 100 Hz | -+-------------------+-----------+------------------------+ -| ``"diagnostic"`` | 500 | 27-class / 500 Hz | -+-------------------+-----------+------------------------+ - -Author: - CS-598 DLH Project Team -""" - -import logging -from typing import Dict, List, Optional - -import numpy as np - -from pyhealth.data import Patient -from pyhealth.tasks import BaseTask - -logger = logging.getLogger(__name__) - -# --------------------------------------------------------------------------- -# Label-space definitions -# --------------------------------------------------------------------------- - -#: Mapping from SNOMED-CT code (string) to one of the 5 PTB-XL superdiagnostic -#: classes. Codes absent from this dict are silently ignored during label -#: construction. The mapping follows Table 1 of Strodthoff et al. (2020) and -#: the PhysioNet Challenge 2020 label alignment documented in the challenge -#: description paper. -SNOMED_TO_SUPERDIAG: Dict[str, str] = { - # ------ NORM — Normal sinus rhythm ----------------------------------- # - "426783006": "NORM", - # ------ MI — Myocardial Infarction ----------------------------------- # - "57054005": "MI", # Acute myocardial infarction - "164865005": "MI", # Myocardial infarction - "413444003": "MI", # Acute MI of anterolateral wall - "413867000": "MI", # Acute MI of inferior wall - "164861001": "MI", # Anterior MI - "164857002": "MI", # Inferior MI - "164860000": "MI", # Anteroseptal MI - "164864009": "MI", # Posterior MI - "164867002": "MI", # Lateral MI - # ------ STTC — ST/T-wave Change -------------------------------------- # - "164931005": "STTC", # ST elevation - "164934002": "STTC", # ST depression - "59931005": "STTC", # Inverted T-wave / T-wave abnormality - "164947007": "STTC", # Prolonged PR interval - "164917005": "STTC", # Prolonged QT interval - "251268003": "STTC", # Early repolarisation pattern - "428750005": "STTC", # Non-specific ST-T change - # ------ CD — Conduction Disturbance / Rhythm Disorder ---------------- # - "270492004": "CD", # First-degree AV block - "195042002": "CD", # Second-degree AV block - "27885002": "CD", # Third-degree AV block - "6374002": "CD", # Bundle branch block (unspecified) - "713427006": "CD", # Complete right bundle branch block (CRBBB) - "713426002": "CD", # Complete left bundle branch block (CLBBB) - "164909002": "CD", # Left bundle branch block - "59118001": "CD", # Right bundle branch block - "698252002": "CD", # Non-specific intraventricular conduction disturbance - "445118002": "CD", # Left anterior fascicular block (LAFB) - "10370003": "CD", # Pacing rhythm - "164889003": "CD", # Atrial fibrillation - "164890007": "CD", # Atrial flutter - "426627000": "CD", # Bradycardia - "427393009": "CD", # Sinus arrhythmia - "426177001": "CD", # Sinus bradycardia - "427084000": "CD", # Sinus tachycardia - "63593006": "CD", # Supraventricular premature beats - "17338001": "CD", # Ventricular premature beats - "284470004": "CD", # Premature atrial contraction - "427172004": "CD", # Premature ventricular contraction - # ------ HYP — Hypertrophy / Axis Deviation --------------------------- # - "55827005": "HYP", # Left ventricular hypertrophy - "446358003": "HYP", # Right ventricular hypertrophy - "73282002": "HYP", # Biventricular hypertrophy - "67751000119106": "HYP", # Left atrial enlargement - "446813000": "HYP", # Right atrial enlargement - "39732003": "HYP", # Left axis deviation - "47665007": "HYP", # Right axis deviation - "251146004": "HYP", # Low QRS voltage -} - -#: Ordered list of the 5 superdiagnostic class names. The ordering is -#: deterministic so that model outputs are consistently interpretable. -SUPERDIAG_CLASSES: List[str] = ["NORM", "MI", "STTC", "CD", "HYP"] - -#: The 27 SNOMED-CT codes officially scored in the PhysioNet/CinC Challenge -#: 2020 (alphabetically sorted by their clinical abbreviation for readability). -#: These form the label universe for ``label_type="diagnostic"``. -CHALLENGE_SNOMED_CLASSES: List[str] = sorted( - [ - "270492004", # IAVB — First-degree atrioventricular block - "164889003", # AF — Atrial fibrillation - "164890007", # AFL — Atrial flutter - "6374002", # BBB — Bundle branch block (unspecified) - "426627000", # Brady — Bradycardia - "713427006", # CRBBB — Complete right bundle branch block - "713426002", # CLBBB — Complete left bundle branch block - "445118002", # LAnFB — Left anterior fascicular block - "39732003", # LAD — Left axis deviation - "164909002", # LBBB — Left bundle branch block - "251146004", # LQRSV — Low QRS voltage - "698252002", # NSIVCB — Non-specific intraventricular conduction dist. - "10370003", # PR — Pacing rhythm - "164947007", # LPR — Prolonged PR interval - "164917005", # LQT — Prolonged QT interval - "47665007", # RAD — Right axis deviation - "427393009", # SA — Sinus arrhythmia - "426177001", # SB — Sinus bradycardia - "426783006", # NSR — Normal sinus rhythm - "427084000", # ST — Sinus tachycardia - "63593006", # SVPB — Supraventricular premature beats - "164934002", # STD — ST depression - "59931005", # TWA — T-wave abnormality - "164931005", # STE — ST elevation - "17338001", # VPB — Ventricular premature beats - "284470004", # PAC — Premature atrial contraction - "427172004", # PVC — Premature ventricular contraction - ] -) - -_CHALLENGE_SET: frozenset = frozenset(CHALLENGE_SNOMED_CLASSES) - - -# --------------------------------------------------------------------------- -# Task class -# --------------------------------------------------------------------------- - - -class PTBXLMultilabelClassification(BaseTask): - """Multi-label 12-lead ECG classification on PTB-XL. - - For each ECG recording this task: - - 1. Loads the ``.mat`` signal matrix via :func:`scipy.io.loadmat` - (shape ``(12, 5000)`` at 500 Hz). - 2. Optionally decimates the signal to 100 Hz (shape ``(12, 1000)``). - 3. Parses SNOMED-CT codes from the ``scp_codes`` event attribute. - 4. Maps those codes to the chosen label space (superdiagnostic or - full Challenge 27-class). - 5. Returns one sample dict per valid recording:: - - { - "signal": np.ndarray, # shape (12, T), float32 - "labels": List[str], # positive class names / SNOMED strings - } - - Args: - sampling_rate (int): Target sampling rate in Hz. Accepted values are - ``100`` (decimation ×5 from the native 500 Hz; yields ``T = 1000``) - and ``500`` (no resampling; yields ``T = 5000``). - Defaults to ``100``. - label_type (str): Label vocabulary to use. ``"superdiagnostic"`` - yields 5 classes (NORM, MI, STTC, CD, HYP); - ``"diagnostic"`` yields 27 SNOMED-CT classes from the PhysioNet - Challenge 2020 scoring list. Defaults to ``"superdiagnostic"``. - - Raises: - ValueError: If ``sampling_rate`` is not 100 or 500. - ValueError: If ``label_type`` is not ``"superdiagnostic"`` or - ``"diagnostic"``. - - Examples: - Superdiagnostic task at 100 Hz (default):: - - >>> from pyhealth.datasets import PTBXLDataset - >>> from pyhealth.tasks import PTBXLMultilabelClassification - >>> dataset = PTBXLDataset(root="/data/.../training/ptb-xl/") - >>> task = PTBXLMultilabelClassification() - >>> sample_ds = dataset.set_task(task) - >>> sample_ds[0]["labels"] # e.g. ["NORM"] or ["CD", "STTC"] - - 27-class diagnostic task at 500 Hz (ablation variant):: - - >>> task_27 = PTBXLMultilabelClassification( - ... sampling_rate=500, label_type="diagnostic" - ... ) - >>> sample_ds_27 = dataset.set_task(task_27) - - See Also: - :data:`SNOMED_TO_SUPERDIAG`, :data:`SUPERDIAG_CLASSES`, - :data:`CHALLENGE_SNOMED_CLASSES` - """ - - task_name: str = "PTBXLMultilabelClassification" - input_schema: Dict[str, str] = {"signal": "tensor"} - output_schema: Dict[str, str] = {"labels": "multilabel"} - - def __init__( - self, - sampling_rate: int = 100, - label_type: str = "superdiagnostic", - ) -> None: - super().__init__() - - if sampling_rate not in (100, 500): - raise ValueError( - f"sampling_rate must be 100 or 500, got {sampling_rate}." - ) - if label_type not in ("superdiagnostic", "diagnostic"): - raise ValueError( - "label_type must be 'superdiagnostic' or 'diagnostic', " - f"got '{label_type}'." - ) - - self.sampling_rate = sampling_rate - self.label_type = label_type - - # Disambiguate the task_name so that cached SampleDatasets from - # different configurations do not collide on disk. - self.task_name = ( - f"PTBXLSuperDiagnostic_{sampling_rate}Hz" - if label_type == "superdiagnostic" - else f"PTBXLDiagnostic27_{sampling_rate}Hz" - ) - - # ------------------------------------------------------------------ - # Core logic - # ------------------------------------------------------------------ - - def __call__(self, patient: Patient) -> List[Dict]: - """Extract samples from one patient (= one ECG recording in PTB-XL). - - Args: - patient: A :class:`~pyhealth.data.Patient` object whose events - have ``event_type="ptbxl"`` and carry attributes - ``signal_file``, ``scp_codes``, ``age``, and ``sex``. - - Returns: - A list with at most one sample dict - ``{"signal": np.ndarray, "labels": List[str]}``, or an empty list - if the recording should be skipped (missing file, unrecognised - codes, etc.). - """ - # In PTBXLDataset each patient has exactly one event in the "ptbxl" - # table (record == patient). - events = patient.get_events(event_type="ptbxl") - samples = [] - - for event in events: - # ---- 1. Load the .mat signal -------------------------------- - signal_file = getattr(event, "signal_file", None) - if not signal_file: - logger.debug("Skip %s: no signal_file attribute.", event) - continue - - try: - from scipy.io import loadmat as _loadmat - mat = _loadmat(signal_file) - signal = mat["val"].astype(np.float32) # (12, 5000) @ 500 Hz - except Exception as exc: - logger.warning("Cannot load signal from %s: %s", signal_file, exc) - continue - - if signal.ndim != 2 or signal.shape[0] != 12: - logger.warning( - "Unexpected signal shape %s in %s; skipping.", - signal.shape, - signal_file, - ) - continue - - # ---- 2. Resample if needed (decimation only) ---------------- - # Native rate is 500 Hz (5000 samples / 10 s). - # Decimation by 5 gives 100 Hz (1000 samples / 10 s). - if self.sampling_rate == 100: - signal = signal[:, ::5] # shape (12, 1000) - - # ---- 3. Parse SNOMED-CT codes -------------------------------- - raw_codes: str = str(getattr(event, "scp_codes", "") or "") - codes = [c.strip() for c in raw_codes.split(",") if c.strip()] - - # ---- 4. Map to chosen label space --------------------------- - if self.label_type == "superdiagnostic": - labels = list( - { - SNOMED_TO_SUPERDIAG[c] - for c in codes - if c in SNOMED_TO_SUPERDIAG - } - ) - else: # "diagnostic" — 27-class Challenge vocabulary - labels = [c for c in codes if c in _CHALLENGE_SET] - - if not labels: - # No recognised labels → skip (consistent with other tasks). - continue - - samples.append({"signal": signal, "labels": labels}) - - return samples \ No newline at end of file +"""PTB-XL multi-label ECG classification task. + +This module provides :class:`PTBXLMultilabelClassification`, a +:class:`~pyhealth.tasks.BaseTask` subclass that turns a +:class:`~pyhealth.datasets.PTBXLDataset` into a multi-label classification +problem. + +Two label spaces are supported, selected via the ``label_type`` constructor +argument. This design enables the **ablation study** described in the project +paper: hold the model and training hyper-parameters constant and vary only the +label granularity (and optionally the signal sampling rate) to observe how +label coarseness affects downstream ROC-AUC and F1 performance. + +Mathematical framing +-------------------- +Let :math:`X \\in \\mathbb{R}^{C \\times T}` be a single ECG recording with +:math:`C = 12` leads and :math:`T` time-steps (1,000 at 100 Hz or 5,000 at +500 Hz). Given a label universe of :math:`K` classes, the ground-truth +annotation is a binary vector :math:`y \\in \\{0, 1\\}^K` (multi-hot). + +A model :math:`f_\\theta` maps the ECG to per-class logit scores: + +.. math:: + + \\hat{y} = \\sigma\\!\\left(f_\\theta(X) W^\\top + b\\right) \\in [0,1]^K + +Training minimises the element-wise **binary cross-entropy**: + +.. math:: + + \\mathcal{L} = -\\frac{1}{K} \\sum_{k=1}^{K} + \\Bigl[ y_k \\log \\hat{y}_k + (1 - y_k) \\log (1 - \\hat{y}_k) \\Bigr] + +Evaluation uses **macro-averaged ROC-AUC**: + +.. math:: + + \\overline{\\text{AUC}} = \\frac{1}{K} \\sum_{k=1}^{K} + \\int_0^1 \\text{TPR}_k(t)\\, d\\text{FPR}_k(t) + +and **macro-averaged F1** (at threshold 0.5): + +.. math:: + + \\overline{F_1} = \\frac{1}{K} \\sum_{k=1}^{K} + \\frac{2 \\cdot \\text{TP}_k}{2 \\cdot \\text{TP}_k + \\text{FP}_k + \\text{FN}_k} + +Label spaces +------------ +``"superdiagnostic"`` (:data:`SUPERDIAG_CLASSES` — 5 classes) + Directly mirrors the five PTB-XL superdiagnostic categories from + Strodthoff et al. (2020). SNOMED-CT codes from every recording's + ``# Dx:`` list are mapped to one or more of NORM / MI / STTC / CD / HYP + using :data:`SNOMED_TO_SUPERDIAG`. Records with no mappable code are + skipped. + +``"diagnostic"`` (:data:`CHALLENGE_SNOMED_CLASSES` — 27 classes) + Uses the 27 SNOMED-CT codes that were officially scored in the + PhysioNet/CinC Challenge 2020. Each code present in a recording's + ``# Dx:`` list that falls within this vocabulary becomes a positive label. + Records with no scored codes are skipped. + +Ablation axes +------------- +The two constructor arguments create the natural ablation grid: + ++-------------------+-----------+------------------------+ +| ``label_type`` | ``sampling_rate`` | Description | ++===================+===========+========================+ +| ``"superdiagnostic"`` | 100 | 5-class / 100 Hz | ++-------------------+-----------+------------------------+ +| ``"superdiagnostic"`` | 500 | 5-class / 500 Hz | ++-------------------+-----------+------------------------+ +| ``"diagnostic"`` | 100 | 27-class / 100 Hz | ++-------------------+-----------+------------------------+ +| ``"diagnostic"`` | 500 | 27-class / 500 Hz | ++-------------------+-----------+------------------------+ + +Author: + CS-598 DLH Project Team +""" + +import logging +from typing import Dict, List, Optional + +import numpy as np + +from pyhealth.data import Patient +from pyhealth.tasks import BaseTask + +logger = logging.getLogger(__name__) + +# --------------------------------------------------------------------------- +# Label-space definitions +# --------------------------------------------------------------------------- + +#: Mapping from SNOMED-CT code (string) to one of the 5 PTB-XL superdiagnostic +#: classes. Codes absent from this dict are silently ignored during label +#: construction. The mapping follows Table 1 of Strodthoff et al. (2020) and +#: the PhysioNet Challenge 2020 label alignment documented in the challenge +#: description paper. +SNOMED_TO_SUPERDIAG: Dict[str, str] = { + # ------ NORM — Normal sinus rhythm ----------------------------------- # + "426783006": "NORM", + # ------ MI — Myocardial Infarction ----------------------------------- # + "57054005": "MI", # Acute myocardial infarction + "164865005": "MI", # Myocardial infarction + "413444003": "MI", # Acute MI of anterolateral wall + "413867000": "MI", # Acute MI of inferior wall + "164861001": "MI", # Anterior MI + "164857002": "MI", # Inferior MI + "164860000": "MI", # Anteroseptal MI + "164864009": "MI", # Posterior MI + "164867002": "MI", # Lateral MI + # ------ STTC — ST/T-wave Change -------------------------------------- # + "164931005": "STTC", # ST elevation + "164934002": "STTC", # ST depression + "59931005": "STTC", # Inverted T-wave / T-wave abnormality + "164947007": "STTC", # Prolonged PR interval + "164917005": "STTC", # Prolonged QT interval + "251268003": "STTC", # Early repolarisation pattern + "428750005": "STTC", # Non-specific ST-T change + # ------ CD — Conduction Disturbance / Rhythm Disorder ---------------- # + "270492004": "CD", # First-degree AV block + "195042002": "CD", # Second-degree AV block + "27885002": "CD", # Third-degree AV block + "6374002": "CD", # Bundle branch block (unspecified) + "713427006": "CD", # Complete right bundle branch block (CRBBB) + "713426002": "CD", # Complete left bundle branch block (CLBBB) + "164909002": "CD", # Left bundle branch block + "59118001": "CD", # Right bundle branch block + "698252002": "CD", # Non-specific intraventricular conduction disturbance + "445118002": "CD", # Left anterior fascicular block (LAFB) + "10370003": "CD", # Pacing rhythm + "164889003": "CD", # Atrial fibrillation + "164890007": "CD", # Atrial flutter + "426627000": "CD", # Bradycardia + "427393009": "CD", # Sinus arrhythmia + "426177001": "CD", # Sinus bradycardia + "427084000": "CD", # Sinus tachycardia + "63593006": "CD", # Supraventricular premature beats + "17338001": "CD", # Ventricular premature beats + "284470004": "CD", # Premature atrial contraction + "427172004": "CD", # Premature ventricular contraction + # ------ HYP — Hypertrophy / Axis Deviation --------------------------- # + "55827005": "HYP", # Left ventricular hypertrophy + "446358003": "HYP", # Right ventricular hypertrophy + "73282002": "HYP", # Biventricular hypertrophy + "67751000119106": "HYP", # Left atrial enlargement + "446813000": "HYP", # Right atrial enlargement + "39732003": "HYP", # Left axis deviation + "47665007": "HYP", # Right axis deviation + "251146004": "HYP", # Low QRS voltage +} + +#: Ordered list of the 5 superdiagnostic class names. The ordering is +#: deterministic so that model outputs are consistently interpretable. +SUPERDIAG_CLASSES: List[str] = ["NORM", "MI", "STTC", "CD", "HYP"] + +#: The 27 SNOMED-CT codes officially scored in the PhysioNet/CinC Challenge +#: 2020 (alphabetically sorted by their clinical abbreviation for readability). +#: These form the label universe for ``label_type="diagnostic"``. +CHALLENGE_SNOMED_CLASSES: List[str] = sorted( + [ + "270492004", # IAVB — First-degree atrioventricular block + "164889003", # AF — Atrial fibrillation + "164890007", # AFL — Atrial flutter + "6374002", # BBB — Bundle branch block (unspecified) + "426627000", # Brady — Bradycardia + "713427006", # CRBBB — Complete right bundle branch block + "713426002", # CLBBB — Complete left bundle branch block + "445118002", # LAnFB — Left anterior fascicular block + "39732003", # LAD — Left axis deviation + "164909002", # LBBB — Left bundle branch block + "251146004", # LQRSV — Low QRS voltage + "698252002", # NSIVCB — Non-specific intraventricular conduction dist. + "10370003", # PR — Pacing rhythm + "164947007", # LPR — Prolonged PR interval + "164917005", # LQT — Prolonged QT interval + "47665007", # RAD — Right axis deviation + "427393009", # SA — Sinus arrhythmia + "426177001", # SB — Sinus bradycardia + "426783006", # NSR — Normal sinus rhythm + "427084000", # ST — Sinus tachycardia + "63593006", # SVPB — Supraventricular premature beats + "164934002", # STD — ST depression + "59931005", # TWA — T-wave abnormality + "164931005", # STE — ST elevation + "17338001", # VPB — Ventricular premature beats + "284470004", # PAC — Premature atrial contraction + "427172004", # PVC — Premature ventricular contraction + ] +) + +_CHALLENGE_SET: frozenset = frozenset(CHALLENGE_SNOMED_CLASSES) + + +# --------------------------------------------------------------------------- +# Task class +# --------------------------------------------------------------------------- + + +class PTBXLMultilabelClassification(BaseTask): + """Multi-label 12-lead ECG classification on PTB-XL. + + For each ECG recording this task: + + 1. Loads the ``.mat`` signal matrix via :func:`scipy.io.loadmat` + (shape ``(12, 5000)`` at 500 Hz). + 2. Optionally decimates the signal to 100 Hz (shape ``(12, 1000)``). + 3. Parses SNOMED-CT codes from the ``scp_codes`` event attribute. + 4. Maps those codes to the chosen label space (superdiagnostic or + full Challenge 27-class). + 5. Returns one sample dict per valid recording:: + + { + "signal": np.ndarray, # shape (12, T), float32 + "labels": List[str], # positive class names / SNOMED strings + } + + Args: + sampling_rate (int): Target sampling rate in Hz. Accepted values are + ``100`` (decimation ×5 from the native 500 Hz; yields ``T = 1000``) + and ``500`` (no resampling; yields ``T = 5000``). + Defaults to ``100``. + label_type (str): Label vocabulary to use. ``"superdiagnostic"`` + yields 5 classes (NORM, MI, STTC, CD, HYP); + ``"diagnostic"`` yields 27 SNOMED-CT classes from the PhysioNet + Challenge 2020 scoring list. Defaults to ``"superdiagnostic"``. + + Raises: + ValueError: If ``sampling_rate`` is not 100 or 500. + ValueError: If ``label_type`` is not ``"superdiagnostic"`` or + ``"diagnostic"``. + + Examples: + Superdiagnostic task at 100 Hz (default):: + + >>> from pyhealth.datasets import PTBXLDataset + >>> from pyhealth.tasks import PTBXLMultilabelClassification + >>> dataset = PTBXLDataset(root="/data/.../training/ptb-xl/") + >>> task = PTBXLMultilabelClassification() + >>> sample_ds = dataset.set_task(task) + >>> sample_ds[0]["labels"] # e.g. ["NORM"] or ["CD", "STTC"] + + 27-class diagnostic task at 500 Hz (ablation variant):: + + >>> task_27 = PTBXLMultilabelClassification( + ... sampling_rate=500, label_type="diagnostic" + ... ) + >>> sample_ds_27 = dataset.set_task(task_27) + + See Also: + :data:`SNOMED_TO_SUPERDIAG`, :data:`SUPERDIAG_CLASSES`, + :data:`CHALLENGE_SNOMED_CLASSES` + """ + + task_name: str = "PTBXLMultilabelClassification" + input_schema: Dict[str, str] = {"signal": "tensor"} + output_schema: Dict[str, str] = {"labels": "multilabel"} + + def __init__( + self, + sampling_rate: int = 100, + label_type: str = "superdiagnostic", + ) -> None: + super().__init__() + + if sampling_rate not in (100, 500): + raise ValueError( + f"sampling_rate must be 100 or 500, got {sampling_rate}." + ) + if label_type not in ("superdiagnostic", "diagnostic"): + raise ValueError( + "label_type must be 'superdiagnostic' or 'diagnostic', " + f"got '{label_type}'." + ) + + self.sampling_rate = sampling_rate + self.label_type = label_type + + # Disambiguate the task_name so that cached SampleDatasets from + # different configurations do not collide on disk. + self.task_name = ( + f"PTBXLSuperDiagnostic_{sampling_rate}Hz" + if label_type == "superdiagnostic" + else f"PTBXLDiagnostic27_{sampling_rate}Hz" + ) + + # ------------------------------------------------------------------ + # Core logic + # ------------------------------------------------------------------ + + def __call__(self, patient: Patient) -> List[Dict]: + """Extract samples from one patient (= one ECG recording in PTB-XL). + + Args: + patient: A :class:`~pyhealth.data.Patient` object whose events + have ``event_type="ptbxl"`` and carry attributes + ``signal_file``, ``scp_codes``, ``age``, and ``sex``. + + Returns: + A list with at most one sample dict + ``{"signal": np.ndarray, "labels": List[str]}``, or an empty list + if the recording should be skipped (missing file, unrecognised + codes, etc.). + """ + # In PTBXLDataset each patient has exactly one event in the "ptbxl" + # table (record == patient). + events = patient.get_events(event_type="ptbxl") + samples = [] + + for event in events: + # ---- 1. Load the .mat signal -------------------------------- + signal_file = getattr(event, "signal_file", None) + if not signal_file: + logger.debug("Skip %s: no signal_file attribute.", event) + continue + + try: + from scipy.io import loadmat as _loadmat + mat = _loadmat(signal_file) + signal = mat["val"].astype(np.float32) # (12, 5000) @ 500 Hz + except Exception as exc: + logger.warning("Cannot load signal from %s: %s", signal_file, exc) + continue + + if signal.ndim != 2 or signal.shape[0] != 12: + logger.warning( + "Unexpected signal shape %s in %s; skipping.", + signal.shape, + signal_file, + ) + continue + + # ---- 2. Resample if needed (decimation only) ---------------- + # Native rate is 500 Hz (5000 samples / 10 s). + # Decimation by 5 gives 100 Hz (1000 samples / 10 s). + if self.sampling_rate == 100: + signal = signal[:, ::5] # shape (12, 1000) + + # ---- 3. Parse SNOMED-CT codes -------------------------------- + raw_codes: str = str(getattr(event, "scp_codes", "") or "") + codes = [c.strip() for c in raw_codes.split(",") if c.strip()] + + # ---- 4. Map to chosen label space --------------------------- + if self.label_type == "superdiagnostic": + labels = list( + { + SNOMED_TO_SUPERDIAG[c] + for c in codes + if c in SNOMED_TO_SUPERDIAG + } + ) + else: # "diagnostic" — 27-class Challenge vocabulary + labels = [c for c in codes if c in _CHALLENGE_SET] + + if not labels: + # No recognised labels → skip (consistent with other tasks). + continue + + samples.append({"signal": signal, "labels": labels}) + + return samples diff --git a/tests/core/test_ptbxl.py b/tests/core/test_ptbxl.py new file mode 100644 index 000000000..ad1226e68 --- /dev/null +++ b/tests/core/test_ptbxl.py @@ -0,0 +1,454 @@ +"""Unit tests for PTBXLDataset and PTBXLMultilabelClassification. + +Test strategy +------------- +* All tests are self-contained and run fully offline — no network calls, no + real ECG data required. +* ``TestPTBXLDataset`` exercises ``prepare_metadata`` in isolation by creating + a minimal temporary filesystem (tiny ``.hea`` header stubs + zero-byte + ``.mat`` placeholders) and verifying the CSV produced. +* ``TestPTBXLMultilabelClassification`` exercises the task's ``__call__`` + method with synthetic in-memory ECG arrays, bypassing the dataset loading + machinery entirely. Both ``label_type`` variants and both ``sampling_rate`` + values are tested. + +Author: + CS-598 DLH Project Team +""" + +import io +import os +import struct +import tempfile +import unittest +from dataclasses import dataclass, field +from pathlib import Path +from typing import List +from unittest.mock import patch + +import numpy as np +import pandas as pd + +from pyhealth.datasets.ptbxl import PTBXLDataset +from pyhealth.tasks.ptbxl_multilabel_classification import ( + CHALLENGE_SNOMED_CLASSES, + SNOMED_TO_SUPERDIAG, + SUPERDIAG_CLASSES, + PTBXLMultilabelClassification, +) + + +# --------------------------------------------------------------------------- +# Helpers for constructing a minimal fake filesystem +# --------------------------------------------------------------------------- + +def _write_hea(path: Path, record_id: str, age: int, sex: str, dx: str) -> None: + """Write a minimal WFDB-style .hea file with the required comment lines.""" + header = ( + f"{record_id} 12 500 5000\n" + f"# Age: {age}\n" + f"# Sex: {sex}\n" + f"# Dx: {dx}\n" + ) + path.write_text(header, encoding="utf-8") + + +def _write_mat(path: Path) -> None: + """Write a zero-byte placeholder .mat file (sufficient for metadata tests).""" + path.write_bytes(b"") + + +def _make_mat_bytes(signal: np.ndarray) -> bytes: + """Produce a minimal scipy.io.savemat-compatible bytes object in memory. + + We use scipy.io.savemat rather than a home-rolled format so that loadmat + can round-trip the data correctly. + """ + import scipy.io + buf = io.BytesIO() + scipy.io.savemat(buf, {"val": signal}) + return buf.getvalue() + + +# --------------------------------------------------------------------------- +# Fake Patient / Event for task tests +# --------------------------------------------------------------------------- + +@dataclass +class _FakeEvent: + signal_file: str = "" + scp_codes: str = "" + age: int = 50 + sex: str = "Male" + + +class _FakePatient: + def __init__(self, patient_id: str, events: List[_FakeEvent]): + self.patient_id = patient_id + self._events = events + + def get_events(self, event_type: str = None) -> List[_FakeEvent]: + return self._events + + +# --------------------------------------------------------------------------- +# Dataset metadata tests +# --------------------------------------------------------------------------- + +class TestPTBXLDataset(unittest.TestCase): + """Test PTBXLDataset.prepare_metadata without touching BaseDataset.__init__.""" + + def _make_ds(self, root: str) -> PTBXLDataset: + """Instantiate PTBXLDataset bypassing BaseDataset initialisation.""" + ds = PTBXLDataset.__new__(PTBXLDataset) + ds.root = root + return ds + + # ------------------------------------------------------------------ + # Baseline: single group directory + # ------------------------------------------------------------------ + + def test_prepare_metadata_basic(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + g1 = root / "g1" + g1.mkdir() + + _write_hea(g1 / "HR00001.hea", "HR00001", 56, "Female", "426783006,251146004") + _write_mat(g1 / "HR00001.mat") + _write_hea(g1 / "HR00002.hea", "HR00002", 42, "Male", "270492004") + _write_mat(g1 / "HR00002.mat") + + ds = self._make_ds(tmp) + ds.prepare_metadata() + + csv = root / "ptbxl-pyhealth.csv" + self.assertTrue(csv.exists(), "ptbxl-pyhealth.csv should be written") + + df = pd.read_csv(csv) + self.assertEqual(len(df), 2) + self.assertIn("patient_id", df.columns) + self.assertIn("record_id", df.columns) + self.assertIn("signal_file", df.columns) + self.assertIn("age", df.columns) + self.assertIn("sex", df.columns) + self.assertIn("scp_codes", df.columns) + + row = df[df["patient_id"] == "HR00001"].iloc[0] + self.assertEqual(row["age"], 56) + self.assertEqual(row["sex"], "Female") + self.assertEqual(row["scp_codes"], "426783006,251146004") + self.assertTrue(str(row["signal_file"]).endswith("HR00001.mat")) + + # ------------------------------------------------------------------ + # Multiple group directories + # ------------------------------------------------------------------ + + def test_prepare_metadata_multiple_groups(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + for g, rec_id in [("g1", "HR00001"), ("g2", "HR01001"), ("g3", "HR02001")]: + gdir = root / g + gdir.mkdir() + _write_hea(gdir / f"{rec_id}.hea", rec_id, 30, "Male", "426783006") + _write_mat(gdir / f"{rec_id}.mat") + + ds = self._make_ds(tmp) + ds.prepare_metadata() + + df = pd.read_csv(root / "ptbxl-pyhealth.csv") + self.assertEqual(len(df), 3) + self.assertEqual(sorted(df["patient_id"].tolist()), sorted(["HR00001", "HR01001", "HR02001"])) + + # ------------------------------------------------------------------ + # Missing .mat → row is skipped + # ------------------------------------------------------------------ + + def test_prepare_metadata_skips_missing_mat(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + g1 = root / "g1" + g1.mkdir() + + _write_hea(g1 / "HR00001.hea", "HR00001", 45, "Male", "426783006") + # deliberately omit HR00001.mat + _write_hea(g1 / "HR00002.hea", "HR00002", 30, "Female", "270492004") + _write_mat(g1 / "HR00002.mat") + + ds = self._make_ds(tmp) + ds.prepare_metadata() + + df = pd.read_csv(root / "ptbxl-pyhealth.csv") + self.assertEqual(len(df), 1) + self.assertEqual(df.iloc[0]["patient_id"], "HR00002") + + # ------------------------------------------------------------------ + # Idempotency: calling prepare_metadata twice should not raise + # ------------------------------------------------------------------ + + def test_prepare_metadata_idempotent(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + g1 = root / "g1" + g1.mkdir() + _write_hea(g1 / "HR00001.hea", "HR00001", 50, "Male", "426783006") + _write_mat(g1 / "HR00001.mat") + + ds = self._make_ds(tmp) + ds.prepare_metadata() + ds.prepare_metadata() # second call should be a no-op + + df = pd.read_csv(root / "ptbxl-pyhealth.csv") + self.assertEqual(len(df), 1) + + # ------------------------------------------------------------------ + # No .hea files → RuntimeError + # ------------------------------------------------------------------ + + def test_prepare_metadata_no_records_raises(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "g1").mkdir() # empty group dir + + ds = self._make_ds(tmp) + with self.assertRaises(RuntimeError): + ds.prepare_metadata() + + # ------------------------------------------------------------------ + # default_task property + # ------------------------------------------------------------------ + + def test_default_task_returns_superdiagnostic_instance(self): + ds = PTBXLDataset.__new__(PTBXLDataset) + task = ds.default_task + self.assertIsInstance(task, PTBXLMultilabelClassification) + self.assertEqual(task.label_type, "superdiagnostic") + self.assertEqual(task.sampling_rate, 100) + + +# --------------------------------------------------------------------------- +# Task unit tests +# --------------------------------------------------------------------------- + +class TestPTBXLMultilabelClassification(unittest.TestCase): + """Test PTBXLMultilabelClassification.__call__ with synthetic ECG data.""" + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def _make_mat_file(self, tmp_dir: Path, name: str, signal: np.ndarray) -> str: + """Write a scipy .mat file containing 'val' and return its path.""" + import scipy.io + path = tmp_dir / name + scipy.io.savemat(str(path), {"val": signal}) + return str(path) + + def _make_patient(self, signal_file: str, scp_codes: str) -> _FakePatient: + event = _FakeEvent(signal_file=signal_file, scp_codes=scp_codes) + return _FakePatient("p001", [event]) + + # ------------------------------------------------------------------ + # Constructor validation + # ------------------------------------------------------------------ + + def test_invalid_sampling_rate_raises(self): + with self.assertRaises(ValueError): + PTBXLMultilabelClassification(sampling_rate=250) + + def test_invalid_label_type_raises(self): + with self.assertRaises(ValueError): + PTBXLMultilabelClassification(label_type="morphological") + + def test_task_names_are_unique(self): + t_a = PTBXLMultilabelClassification(sampling_rate=100, label_type="superdiagnostic") + t_b = PTBXLMultilabelClassification(sampling_rate=500, label_type="superdiagnostic") + t_c = PTBXLMultilabelClassification(sampling_rate=100, label_type="diagnostic") + t_d = PTBXLMultilabelClassification(sampling_rate=500, label_type="diagnostic") + names = {t_a.task_name, t_b.task_name, t_c.task_name, t_d.task_name} + self.assertEqual(len(names), 4, "All four configurations should have distinct task names.") + + # ------------------------------------------------------------------ + # Signal loading and decimation + # ------------------------------------------------------------------ + + def test_superdiagnostic_100hz_signal_shape(self): + """Superdiagnostic task at 100 Hz should yield (12, 1000) signals.""" + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") # NORM + + task = PTBXLMultilabelClassification(sampling_rate=100, label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertEqual(samples[0]["signal"].shape, (12, 1000)) + + def test_superdiagnostic_500hz_signal_shape(self): + """Superdiagnostic task at 500 Hz should yield (12, 5000) signals (no decimation).""" + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") # NORM + + task = PTBXLMultilabelClassification(sampling_rate=500, label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertEqual(samples[0]["signal"].shape, (12, 5000)) + + def test_signal_dtype_is_float32(self): + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float64) # 64-bit input + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") + + task = PTBXLMultilabelClassification() + samples = task(patient) + self.assertEqual(samples[0]["signal"].dtype, np.float32) + + # ------------------------------------------------------------------ + # Superdiagnostic label mapping + # ------------------------------------------------------------------ + + def test_superdiagnostic_normal_label(self): + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "426783006") # → NORM + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertIn("NORM", samples[0]["labels"]) + + def test_superdiagnostic_multilabel(self): + """A recording with both AF (CD) and low QRS voltage (HYP) codes.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + # 164889003 → CD (atrial fibrillation), 251146004 → HYP (low QRS voltage) + patient = self._make_patient(mat_path, "164889003,251146004") + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + label_set = set(samples[0]["labels"]) + self.assertIn("CD", label_set) + self.assertIn("HYP", label_set) + + def test_superdiagnostic_no_known_codes_skipped(self): + """Recordings with no recognised superdiagnostic codes should be skipped.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "999999999") # unknown code + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + # ------------------------------------------------------------------ + # Diagnostic (27-class) label mapping + # ------------------------------------------------------------------ + + def test_diagnostic_known_challenge_code(self): + # 270492004 = First-degree AV block, part of Challenge 2020 scoring set + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "270492004") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertIn("270492004", samples[0]["labels"]) + + def test_diagnostic_non_challenge_code_skipped(self): + """A code not in the 27-class Challenge vocabulary should be filtered out.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "999999999") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + def test_diagnostic_multiple_valid_codes(self): + """Multiple Challenge codes in one recording should all appear as labels.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + # 164889003 (AF) and 426783006 (NSR) are both in Challenge vocabulary + patient = self._make_patient(mat_path, "164889003,426783006") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + label_set = set(samples[0]["labels"]) + self.assertIn("164889003", label_set) + self.assertIn("426783006", label_set) + + # ------------------------------------------------------------------ + # Edge cases + # ------------------------------------------------------------------ + + def test_missing_signal_file_returns_empty(self): + event = _FakeEvent(signal_file="", scp_codes="426783006") + patient = _FakePatient("p001", [event]) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_nonexistent_signal_file_returns_empty(self): + event = _FakeEvent(signal_file="/nonexistent/path/to/rec.mat", scp_codes="426783006") + patient = _FakePatient("p001", [event]) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_empty_patient_no_events(self): + patient = _FakePatient("p001", []) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_wrong_signal_shape_skipped(self): + """Signals that are not 2-D with 12 channels should be skipped.""" + with tempfile.TemporaryDirectory() as tmp: + # Write a single-channel signal (shape 1×5000) + signal = np.zeros((1, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + event = _FakeEvent(signal_file=mat_path, scp_codes="426783006") + patient = _FakePatient("p001", [event]) + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + # ------------------------------------------------------------------ + # Label-space constants sanity checks + # ------------------------------------------------------------------ + + def test_superdiag_classes_count(self): + self.assertEqual(len(SUPERDIAG_CLASSES), 5) + self.assertEqual(set(SUPERDIAG_CLASSES), {"NORM", "MI", "STTC", "CD", "HYP"}) + + def test_challenge_classes_count(self): + self.assertEqual(len(CHALLENGE_SNOMED_CLASSES), 27) + + def test_snomed_to_superdiag_values(self): + valid_classes = set(SUPERDIAG_CLASSES) + for code, cls in SNOMED_TO_SUPERDIAG.items(): + self.assertIn( + cls, + valid_classes, + f"SNOMED code {code} maps to unknown class '{cls}'", + ) + + +if __name__ == "__main__": + unittest.main() From 67b7f5a2ffdc5d0dba73a623d41f15bde1af5677 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Mon, 13 Apr 2026 00:12:51 -0700 Subject: [PATCH 02/10] update: adapt notebook to jtwells2 CinC 2020 ptbxl format (SNOMED-CT labels) --- cs598_project/ptbxl_pyhealth_pipeline.ipynb | 749 +++++++++++++------- 1 file changed, 507 insertions(+), 242 deletions(-) diff --git a/cs598_project/ptbxl_pyhealth_pipeline.ipynb b/cs598_project/ptbxl_pyhealth_pipeline.ipynb index 3b9e7746b..6084273a5 100644 --- a/cs598_project/ptbxl_pyhealth_pipeline.ipynb +++ b/cs598_project/ptbxl_pyhealth_pipeline.ipynb @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, "id": "89ecd1c1", "metadata": {}, "outputs": [ @@ -53,6 +53,14 @@ " Device : mps\n", " PyHealth: 1.1.6\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/pyhealth/trainer.py:12: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from tqdm.autonotebook import trange\n" + ] } ], "source": [ @@ -129,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "bdcff606", "metadata": {}, "outputs": [ @@ -277,7 +285,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "id": "8257b112", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, "id": "ccc4653b", "metadata": {}, "outputs": [ @@ -286,8 +302,8 @@ "output_type": "stream", "text": [ "Data format : ptbxl_wfdb\n", - "DB CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/ptbxl_database.csv ✅\n", - "WFDB root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB ✅\n", + "DB CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/ptbxl_database.csv ✅\n", + "WFDB root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/WFDB ✅\n", "ptbxl_database.csv shape : (21799, 27)\n", "Unique patients : 18,869\n", "ECG recordings : 21,799\n", @@ -570,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "f3bb5d93", "metadata": {}, "outputs": [ @@ -578,149 +594,229 @@ "name": "stdout", "output_type": "stream", "text": [ - "Initialising PyHealth PTBXLDataset …\n", + "Step 4a: Generating ptbxl-pyhealth.csv (jtwells2 prepare_metadata logic) …\n", + " CinC root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", + " CSV already exists: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + "\n", + "✅ CSV: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + " Shape : (21837, 10) (21,837 records × 10 cols)\n", + " Columns : ['patient_id', 'record_id', 'signal_file', 'age', 'sex', 'scp_codes', 'sampling_rate', 'num_samples', 'num_leads', 'group']\n", + "\n", + "First 3 rows:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
patient_idrecord_idsignal_fileagesexscp_codessampling_ratenum_samplesnum_leadsgroup
0HR00001HR00001g1/HR00001.mat56.0Female251146004,426783006500500012g1
1HR00002HR00002g1/HR00002.mat19.0Male426177001,426783006500500012g1
2HR00003HR00003g1/HR00003.mat37.0Female426783006500500012g1
\n", + "
" + ], + "text/plain": [ + " patient_id record_id signal_file age sex scp_codes \\\n", + "0 HR00001 HR00001 g1/HR00001.mat 56.0 Female 251146004,426783006 \n", + "1 HR00002 HR00002 g1/HR00002.mat 19.0 Male 426177001,426783006 \n", + "2 HR00003 HR00003 g1/HR00003.mat 37.0 Female 426783006 \n", + "\n", + " sampling_rate num_samples num_leads group \n", + "0 500 5000 12 g1 \n", + "1 500 5000 12 g1 \n", + "2 500 5000 12 g1 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SNOMED-CT code example (row 0): '251146004,426783006'\n", + "(comma-separated SNOMED-CT codes — no confidence percentages)\n", + "\n", + "Step 4b: Initialising BaseSignalDataset adapter …\n", "──────────────────────────────────────────────────────\n", - " PyHealth PTBXLDataset (BaseSignalDataset subclass)\n", - " Patients : 18,869\n", - " ECG records : 21,799\n", - " Avg ECGs/pt : 1.16\n", - " Strat folds : {1: 2175, 2: 2181, 3: 2192, 4: 2174, 5: 2174, 6: 2173, 7: 2176, 8: 2173, 9: 2183, 10: 2198}\n", + " PTBXLDataset (jtwells2 CinC 2020 format)\n", + " Records : 21,837 (patient_id == record_id)\n", + " Label type : SNOMED-CT codes (binary, no confidence)\n", + " strat_fold : not available → random 80/10/10 split\n", "──────────────────────────────────────────────────────\n" ] } ], "source": [ - "# ── STEP 4: PTBXLDataset — extends PyHealth's BaseSignalDataset ──────────────\n", + "# ── STEP 4: PTBXLDataset — updated for jtwells2's CinC 2020 format ──────────\n", + "#\n", + "# jtwells2's ptbxl.py (pyhealth.datasets.PTBXLDataset) now targets the CinC\n", + "# 2020 PTB-XL subset. It scans g1/...g22/ .hea files and generates\n", + "# ptbxl-pyhealth.csv with columns:\n", + "#\n", + "# patient_id = record stem (e.g. \"HR00001\") ← same as record_id\n", + "# record_id = record stem\n", + "# signal_file = absolute path to .mat file\n", + "# age, sex = from .hea header (# Age: / # Sex:)\n", + "# scp_codes = SNOMED-CT codes e.g. \"426783006,251146004\"\n", "#\n", - "# PyHealth's BaseSignalDataset is the standard abstract base class for any\n", - "# dataset that stores one signal (ECG, EEG, waveform) per patient.\n", + "# KEY CHANGE vs PTB-XL v1.0.3 native format:\n", + "# OLD → scp_codes = {\"NORM\": 100.0, \"SR\": 0.0} (SCP abbrevs + confidence %)\n", + "# NEW → scp_codes = \"426783006,251146004\" (SNOMED-CT codes, binary)\n", "#\n", - "# Subclass contract:\n", - "# • Override process_EEG_data() → return { patient_id: [record_dict, ...] }\n", - "# • Calling dataset.set_task(task_fn) iterates this dict, calls task_fn on\n", - "# each patient's records list, and returns a SampleSignalDataset.\n", + "# Since patient_id == record_id (no true patient metadata in .hea files),\n", + "# multi-ECG patient grouping is lost; split_by_patient becomes per-recording.\n", "#\n", - "# Key design: No signals are loaded here — only file paths are stored\n", - "# (lazy loading happens inside the task function).\n", + "# We use jtwells2's class for Step 4a (CSV generation) and then wrap it in our\n", + "# own BaseSignalDataset subclass for Step 4b (Trainer-compatible pipeline).\n", "\n", - "from scipy.io import loadmat as scipy_loadmat\n", + "from pyhealth.datasets import PTBXLDataset as JTWellsPTBXLDataset\n", + "\n", + "CINC_PTBXL_ROOT = (\n", + " _PROJECT_ROOT.parent.parent /\n", + " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", + " / \"training\" / \"ptb-xl\"\n", + ")\n", "\n", + "# ── Step 4a: Use jtwells2's class to generate ptbxl-pyhealth.csv ─────────────\n", + "print(\"Step 4a: Generating ptbxl-pyhealth.csv via jtwells2's PTBXLDataset …\")\n", + "print(f\" CinC root : {CINC_PTBXL_ROOT}\")\n", + "jt_dataset = JTWellsPTBXLDataset(root=str(CINC_PTBXL_ROOT))\n", + "\n", + "_generated_csv = CINC_PTBXL_ROOT / \"ptbxl-pyhealth.csv\"\n", + "_cache_csv = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\" / \"ptbxl-pyhealth.csv\"\n", + "csv_path = _generated_csv if _generated_csv.exists() else _cache_csv\n", + "\n", + "df_meta = pd.read_csv(csv_path)\n", + "print(f\"\\n✅ CSV written to: {csv_path}\")\n", + "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records × {df_meta.shape[1]} cols)\")\n", + "print(f\" Columns : {df_meta.columns.tolist()}\")\n", + "print(f\"\\nFirst 3 rows:\")\n", + "display(df_meta.head(3))\n", + "print(f\"\\nSNOMED-CT code example (row 0): '{df_meta['scp_codes'].iloc[0]}'\")\n", + "print(\"(comma-separated SNOMED-CT numeric codes — no confidence percentages)\")\n", + "\n", + "# ── Step 4b: Wrap CSV in BaseSignalDataset for the Trainer pipeline ───────────\n", + "#\n", + "# jtwells2's class extends BaseDataset (YAML-driven, structured visits).\n", + "# Our SparcNet/BiLSTMECG pipeline uses BaseSignalDataset.set_task(task_fn).\n", + "# The two APIs are incompatible, so we define a thin adapter below.\n", "\n", "class PTBXLDataset(BaseSignalDataset):\n", " \"\"\"\n", - " PTB-XL 12-lead ECG dataset.\n", - "\n", - " Extends ``pyhealth.datasets.BaseSignalDataset`` so it is fully\n", - " compatible with PyHealth's Trainer, splitter, and model APIs.\n", + " BaseSignalDataset adapter over jtwells2's ptbxl-pyhealth.csv.\n", "\n", - " Directory layout expected::\n", + " Reads the CSV produced by JTWellsPTBXLDataset.prepare_metadata() and\n", + " implements process_EEG_data() so the existing Trainer/SparcNet pipeline\n", + " works unchanged.\n", "\n", - " root/\n", - " ptbxl_database.csv\n", - " scp_statements.csv\n", - " WFDB/\n", - " HR00001.mat (12-lead ECG, 12×5000, 500 Hz)\n", - " HR00001.hea\n", - " HR00002.mat\n", - " ...\n", - "\n", - " Each ``WFDB/HR{:05d}.mat`` file stores the signal in\n", - " ``mat[\"val\"]`` (int16, ADC counts; divide by 200 to get mV).\n", + " Schema change vs PTB-XL v1.0.3:\n", + " scp_codes — comma-separated SNOMED-CT string: \"426783006,251146004\"\n", + " (was dict {\"NORM\": 100.0, ...} with confidence scores)\n", + " patient_id — equals record stem (no true patient grouping)\n", + " strat_fold — NOT PRESENT in CinC .hea files\n", " \"\"\"\n", - "\n", - " def __init__(self, root: str, sampling_rate: int = 500, **kwargs):\n", - " self._ptbxl_root = Path(root)\n", - " self._sampling_rate = sampling_rate\n", - " # super().__init__ immediately calls process_EEG_data()\n", - " super().__init__(root=root, dataset_name=\"ptbxl\", **kwargs)\n", + " def __init__(self, csv_path: str, **kwargs):\n", + " self._csv_path = Path(csv_path)\n", + " super().__init__(root=str(self._csv_path.parent), dataset_name=\"ptbxl\", **kwargs)\n", "\n", " def process_EEG_data(self) -> dict:\n", - " \"\"\"\n", - " Read ``ptbxl_database.csv`` and group ECG records by patient.\n", - "\n", - " Each patient entry stores:\n", - " patient_id – str\n", - " ecg_id – str (integer ecg_id from CSV)\n", - " mat_path – str (absolute path to WFDB/HR{id:05d}.mat)\n", - " scp_codes – dict {code: confidence_float}\n", - " strat_fold – int (1–10)\n", - " age / sex – float / int (demographics, optional)\n", - " \"\"\"\n", - " root = self._ptbxl_root\n", - " csv_path = root / \"ptbxl_database.csv\"\n", - "\n", - " if not csv_path.exists():\n", - " print(\"[PTBXLDataset] ptbxl_database.csv not found — using synthetic data.\")\n", - " return _build_synthetic_patients()\n", - "\n", - " df = pd.read_csv(csv_path, index_col=\"ecg_id\")\n", - " df[\"scp_codes\"] = df[\"scp_codes\"].apply(ast.literal_eval)\n", - " df[\"patient_id\"] = df[\"patient_id\"].astype(int).astype(str)\n", - "\n", + " df = pd.read_csv(self._csv_path)\n", " patients = defaultdict(list)\n", - " wfdb_dir = root / \"WFDB\"\n", - "\n", - " for ecg_id, row in df.iterrows():\n", - " # Flat WFDB layout: WFDB/HR{ecg_id:05d}.mat\n", - " mat_path = wfdb_dir / f\"HR{int(ecg_id):05d}.mat\"\n", - " patients[row[\"patient_id\"]].append({\n", - " \"patient_id\": row[\"patient_id\"],\n", - " \"ecg_id\": str(ecg_id),\n", - " \"mat_path\": str(mat_path), # ← scipy.io.loadmat path\n", - " \"scp_codes\": row[\"scp_codes\"],\n", - " \"strat_fold\": int(row[\"strat_fold\"]),\n", + " for _, row in df.iterrows():\n", + " pid = str(row[\"patient_id\"])\n", + " patients[pid].append({\n", + " \"patient_id\": pid,\n", + " \"ecg_id\": str(row[\"record_id\"]),\n", + " \"mat_path\": str(row[\"signal_file\"]),\n", + " # scp_codes is now a SNOMED-CT comma-separated string\n", + " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", " \"age\": row.get(\"age\"),\n", " \"sex\": row.get(\"sex\"),\n", + " # strat_fold not available → splits will be random by record\n", " })\n", " return dict(patients)\n", "\n", " def stat(self):\n", " total = sum(len(v) for v in self.patients.values())\n", - " folds = defaultdict(int)\n", - " for recs in self.patients.values():\n", - " for r in recs:\n", - " folds[r[\"strat_fold\"]] += 1\n", " print(f\"{'─'*54}\")\n", - " print(f\" PyHealth PTBXLDataset (BaseSignalDataset subclass)\")\n", - " print(f\" Patients : {len(self.patients):,}\")\n", - " print(f\" ECG records : {total:,}\")\n", - " print(f\" Avg ECGs/pt : {total/len(self.patients):.2f}\")\n", - " print(f\" Strat folds : {dict(sorted(folds.items()))}\")\n", + " print(f\" PTBXLDataset (jtwells2 CinC 2020 format)\")\n", + " print(f\" Records : {total:,} (patient_id == record_id)\")\n", + " print(f\" Label type : SNOMED-CT codes (binary, no confidence)\")\n", + " print(f\" strat_fold : not available → random 80/10/10 split\")\n", " print(f\"{'─'*54}\")\n", "\n", "\n", - "def _build_synthetic_patients(n_patients: int = 200,\n", - " ecgs_per_max: int = 3) -> dict:\n", - " \"\"\"Minimal synthetic patients dict — same schema as real PTB-XL.\"\"\"\n", - " rng = np.random.default_rng(42)\n", - " DIAG = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"]\n", - " out = {}\n", - " ecg_id = 1\n", - " for pid in range(1, n_patients + 1):\n", - " n = rng.integers(1, ecgs_per_max + 1)\n", - " recs = []\n", - " for _ in range(n):\n", - " chosen = rng.choice(DIAG, size=rng.integers(1, 3), replace=False)\n", - " scp = {c: float(rng.integers(60, 101)) for c in chosen}\n", - " recs.append({\n", - " \"patient_id\": str(pid),\n", - " \"ecg_id\": str(ecg_id),\n", - " \"mat_path\": \"\", # no real file → synthetic signal\n", - " \"scp_codes\": scp,\n", - " \"strat_fold\": int((pid % 10) + 1),\n", - " \"age\": float(rng.integers(18, 85)),\n", - " \"sex\": int(rng.integers(0, 2)),\n", - " })\n", - " ecg_id += 1\n", - " out[str(pid)] = recs\n", - " return out\n", - "\n", - "\n", - "# ── Instantiate ───────────────────────────────────────────────────────────────\n", - "PTBXL_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", - "\n", - "print(\"Initialising PyHealth PTBXLDataset …\")\n", - "dataset = PTBXLDataset(root=str(PTBXL_ROOT), sampling_rate=500)\n", + "print(\"\\nStep 4b: Wrapping in BaseSignalDataset-compatible PTBXLDataset …\")\n", + "dataset = PTBXLDataset(csv_path=str(csv_path))\n", "dataset.stat()\n" ] }, @@ -751,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "d2854a79", "metadata": {}, "outputs": [ @@ -905,7 +1001,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "7d06120b", "metadata": {}, "outputs": [ @@ -914,160 +1010,133 @@ "output_type": "stream", "text": [ "Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\n", - "(uses pandarallel for parallel patient processing)\n", + "(SNOMED-CT codes from CinC .hea files — binary labels, no threshold)\n", "\n", "INFO: Pandarallel will run on 10 workers.\n", "INFO: Pandarallel will use standard multiprocessing data transfer (pipe) to transfer data between the main process and workers.\n", "\n", - "PyHealth SampleSignalDataset built: 118,930 samples\n", + "SampleSignalDataset: 152,859 samples\n", " input_info: {'signal': {'length': 1250, 'n_channels': 12}, 'label': {'type': , 'dim': 2}}\n", "\n", - " Label prevalence (multi-hot, threshold=50%):\n", - " NORM 55.6% ████████████████\n", - " CD 21.4% ██████\n", - " HYP 13.2% ███\n", - " MI 22.7% ██████\n", - " STTC 3.9% █\n" + "Label prevalence (binary SNOMED-CT mapping):\n", + " NORM 86.9% ██████████████████████████\n", + " CD 50.0% ██████████████\n", + " HYP 29.2% ████████\n", + " MI 3.9% █\n", + " STTC 29.4% ████████\n" ] } ], "source": [ - "# ── STEP 6: PyHealth Task Function — ptbxl_superdiagnostic_fn ────────────────\n", + "# ── STEP 6: Task Function — updated for SNOMED-CT codes (jtwells2 format) ────\n", "#\n", - "# A PyHealth task function:\n", - "# • Takes one patient's record list (from dataset.patients[pid])\n", - "# • Loads the ECG signal (or synthesises one)\n", - "# • Slices into 2.5-second windows with 50% overlap\n", - "# • Maps SCP codes → NORM / CD / HYP / MI / STTC labels\n", - "# • Stores each window as a .pkl file (epoch_path convention from PyHealth)\n", - "# • Returns a List[Dict], one dict per window\n", + "# KEY CHANGE from PTB-XL v1.0.3 native format:\n", + "# OLD: scp_codes = {\"NORM\": 100.0, \"SR\": 0.0}\n", + "# → labels built with confidence threshold >= 50%\n", + "# NEW: scp_codes = \"426783006,251146004\"\n", + "# → all codes are positive (binary), no threshold needed\n", + "# → must map SNOMED-CT numeric codes → NORM / CD / HYP / MI / STTC\n", "#\n", - "# Label format required by PyHealth SparcNet in \"multilabel\" mode:\n", - "# label = List[str], e.g. [\"NORM\"] or [\"CD\", \"STTC\"]\n", - "# (SparcNet.prepare_labels tokenises these → multi-hot tensor)\n", - "#\n", - "# Pickle format required by PyHealth SampleSignalDataset:\n", - "# {\"signal\": np.float32(12, T)} ← ONLY the signal array\n", - "# The \"label\" key stays in the outer sample dict (not in the pickle)\n", - "# so that SampleSignalDataset.__getitem__ leaves it untouched.\n", - "#\n", - "# Required keys in each sample dict (SampleSignalDataset contract):\n", - "# patient_id – str\n", - "# record_id – str ← required by SampleSignalDataset._index_record()\n", - "# epoch_path – str ← path to pkl with {\"signal\": ndarray}\n", - "# label – List[str]\n", + "# Mapping derived by cross-referencing CinC 2020 .hea Dx codes\n", + "# with PTB-XL's ptbxl_database.csv + scp_statements.csv.\n", "\n", "from scipy.io import loadmat as scipy_loadmat\n", "\n", - "# ── SNOMED / SCP code → superdiagnostic class mapping ────────────────────────\n", - "# Source: Table 2 of Strodthoff et al. (2020) and PTB-XL scp_statements.csv\n", + "# ── SNOMED-CT numeric code → superdiagnostic class ───────────────────────────\n", "SNOMED_TO_SUPERDIAG = {\n", - " # --------------- NORM -----------------------------------------------\n", - " \"NORM\": \"NORM\",\n", - " # --------------- CD — Conduction Disturbance / Rhythm ---------------\n", - " \"LAFB\": \"CD\", \"LPFB\": \"CD\", \"IRBBB\": \"CD\", \"RBBB\": \"CD\",\n", - " \"LBBB\": \"CD\", \"IVCD\": \"CD\", \"IAVB\": \"CD\", \"I-AVB\": \"CD\",\n", - " \"WPW\": \"CD\", \"SVTAC\": \"CD\", \"PSVT\": \"CD\", \"AF\": \"CD\",\n", - " \"AFIB\": \"CD\", \"AVNRT\": \"CD\", \"AVRT\": \"CD\",\n", - " # --------------- HYP — Hypertrophy ----------------------------------\n", - " \"LVH\": \"HYP\", \"RVH\": \"HYP\",\n", - " \"LAO/LAE\": \"HYP\", \"RAO/RAE\":\"HYP\",\n", - " # --------------- MI — Myocardial Infarction -------------------------\n", - " \"AMI\": \"MI\", \"IMI\": \"MI\", \"LMI\": \"MI\", \"PMI\": \"MI\",\n", - " \"ISCAL\": \"MI\", \"ISCIN\": \"MI\", \"ISCAN\": \"MI\",\n", - " \"ISCLA\": \"MI\", \"ISC_\": \"MI\",\n", - " # --------------- STTC — ST/T-wave Change ----------------------------\n", - " \"STD_\": \"STTC\", \"STE_\": \"STTC\", \"NST_\": \"STTC\",\n", - " \"STTC\": \"STTC\", \"ANEUR\":\"STTC\",\n", + " # NORM\n", + " \"426783006\": \"NORM\", \"164884008\": \"NORM\", \"427393009\": \"NORM\",\n", + " \"164947007\": \"NORM\", \"47665007\": \"NORM\", \"251146004\": \"NORM\",\n", + " \"164931005\": \"NORM\",\n", + " # CD — Conduction Disturbance\n", + " \"270492004\": \"CD\", \"195042002\": \"CD\", \"164865005\": \"CD\",\n", + " \"426177001\": \"CD\", \"698252002\": \"CD\", \"39732003\": \"CD\",\n", + " \"445118002\": \"CD\", \"74390002\": \"CD\", \"713426002\": \"CD\",\n", + " \"713427006\": \"CD\", \"54329005\": \"CD\", \"445211001\": \"CD\",\n", + " \"251120003\": \"CD\", \"251200008\": \"CD\", \"27885002\": \"CD\",\n", + " \"251180001\": \"CD\", \"164909002\": \"CD\", \"428750005\": \"CD\",\n", + " \"426434006\": \"CD\", \"284470004\": \"CD\",\n", + " # HYP — Hypertrophy\n", + " \"164861001\": \"HYP\", \"164873001\": \"HYP\", \"164934002\": \"HYP\",\n", + " \"67741000119109\": \"HYP\", \"427084000\": \"HYP\", \"446358003\": \"HYP\",\n", + " \"266249003\": \"HYP\", \"89792004\": \"HYP\", \"164890007\": \"HYP\",\n", + " \"426761007\": \"HYP\",\n", + " # MI — Myocardial Infarction\n", + " \"164917005\": \"MI\", \"10370003\": \"MI\",\n", + " # STTC — ST/T-wave change\n", + " \"425623009\": \"STTC\", \"55930002\": \"STTC\", \"164951009\": \"STTC\",\n", + " \"164889003\": \"STTC\", \"429622005\": \"STTC\", \"425419005\": \"STTC\",\n", + " \"111975006\": \"STTC\", \"63593006\": \"STTC\", \"59931005\": \"STTC\",\n", + " \"11157007\": \"STTC\", \"67198005\": \"STTC\",\n", "}\n", "\n", - "SUPERDIAG_CLASSES = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"] # canonical order\n", + "SUPERDIAG_CLASSES = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"]\n", "\n", "\n", "def ptbxl_superdiagnostic_fn(record_list: list,\n", " epoch_sec: float = 2.5,\n", - " freq: int = 500,\n", - " scp_threshold: float = 50.0) -> list:\n", + " freq: int = 500) -> list:\n", " \"\"\"\n", - " PyHealth task function: converts one patient's ECG records into\n", - " a list of windowed samples for multi-label superdiagnostic classification.\n", - "\n", - " Args:\n", - " record_list : list of record dicts from PTBXLDataset.patients[pid]\n", - " epoch_sec : window length in seconds (2.5 s → 1250 samples @ 500 Hz)\n", - " freq : sampling rate (500 Hz)\n", - " scp_threshold : minimum SCP confidence (%) to count as positive\n", - "\n", - " Returns:\n", - " samples : List[Dict], each with keys:\n", - " patient_id – str\n", - " record_id – str (same as ecg_id; required by SampleSignalDataset)\n", - " ecg_id – str\n", - " epoch_path – str (path to pickle containing {\"signal\": ndarray})\n", - " label – List[str] e.g. [\"NORM\"], [\"CD\", \"STTC\"]\n", + " Task function — updated for jtwells2's CinC 2020 format.\n", + "\n", + " scp_codes is now a SNOMED-CT comma-separated string (no confidence).\n", + " All codes listed are treated as positive (binary labels).\n", " \"\"\"\n", - " samples = []\n", - " win_len = int(freq * epoch_sec) # 500 × 2.5 = 1250\n", - " stride = win_len // 2 # 50% overlap\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / \"windows\"\n", + " samples = []\n", + " win_len = int(freq * epoch_sec) # 1250 samples @ 500 Hz\n", + " stride = win_len // 2 # 50% overlap\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / \"windows\"\n", " cache_dir.mkdir(parents=True, exist_ok=True)\n", "\n", " for visit in record_list:\n", " pid = visit[\"patient_id\"]\n", " ecg_id = visit[\"ecg_id\"]\n", " mat_path = visit[\"mat_path\"]\n", - " scp_codes = visit[\"scp_codes\"]\n", + " scp_codes = visit[\"scp_codes\"] # \"426783006,251146004\" (string)\n", "\n", - " # ── 1. Build the label as a List[str] (required by SparcNet multilabel) ──\n", + " # ── 1. Map SNOMED-CT string → superdiagnostic List[str] ───────────────\n", + " snomed_codes = [c.strip() for c in str(scp_codes).split(\",\") if c.strip()]\n", " labels = list({\n", - " SNOMED_TO_SUPERDIAG[c]\n", - " for c, conf in scp_codes.items()\n", - " if c.upper() in SNOMED_TO_SUPERDIAG and float(conf) >= scp_threshold\n", + " SNOMED_TO_SUPERDIAG[code]\n", + " for code in snomed_codes\n", + " if code in SNOMED_TO_SUPERDIAG\n", " })\n", " if not labels:\n", - " continue # skip records with no mappable superdiagnostic code\n", + " continue\n", "\n", - " # ── 2. Load the ECG signal ──────────────────────────────────────────\n", + " # ── 2. Load signal ─────────────────────────────────────────────────────\n", " if mat_path and Path(mat_path).exists():\n", " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV (12, 5000)\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV\n", " else:\n", - " # Synthetic: 1-lead QRS spike pattern, replicated 12 times\n", - " t = np.linspace(0, freq * 10 / freq, freq * 10)\n", + " t = np.linspace(0, 10, freq * 10)\n", " lead = 0.5 * np.sin(2 * np.pi * 1.2 * t) + np.random.randn(freq * 10) * 0.04\n", - " signal = np.tile(lead, (12, 1)).astype(np.float32) # (12, 5000)\n", + " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", "\n", - " # ── 3. Sliding-window segmentation ─────────────────────────────────\n", + " # ── 3. Sliding-window segmentation ────────────────────────────────────\n", " n_windows = max(1, (signal.shape[1] - win_len) // stride + 1)\n", " for idx in range(n_windows):\n", " s = idx * stride\n", - " window = signal[:, s : s + win_len] # (12, 1250)\n", + " window = signal[:, s : s + win_len]\n", " if window.shape[1] < win_len:\n", - " break # skip the last partial window\n", - "\n", - " # Save ONLY the signal in the pickle (label stays in outer dict)\n", + " break\n", " pkl_path = str(cache_dir / f\"{pid}_{ecg_id}_{idx}.pkl\")\n", " with open(pkl_path, \"wb\") as f:\n", " pickle.dump({\"signal\": window}, f)\n", - "\n", " samples.append({\n", " \"patient_id\": pid,\n", - " \"record_id\": ecg_id, # ← required by SampleSignalDataset._index_record()\n", + " \"record_id\": ecg_id,\n", " \"ecg_id\": ecg_id,\n", " \"epoch_path\": pkl_path,\n", - " \"label\": labels, # List[str] — kept in outer dict\n", + " \"label\": labels,\n", " })\n", " return samples\n", "\n", "\n", - "# ── Apply task via PyHealth's BaseSignalDataset.set_task() ────────────────────\n", + "# ── Apply task ────────────────────────────────────────────────────────────────\n", "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\")\n", - "print(\"(uses pandarallel for parallel patient processing)\\n\")\n", + "print(\"(SNOMED-CT codes from CinC .hea files — binary labels, no threshold)\\n\")\n", "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "\n", - "# ── Patch input_info[\"label\"] for multilabel (label = List[str], dim=2) ──────\n", - "# PyHealth 1.1.6 hardcodes dim=0 for \"label\" in SampleSignalDataset._validate().\n", - "# We override it so that get_all_tokens(\"label\") correctly iterates the list.\n", "sample_dataset.input_info[\"label\"] = {\"type\": str, \"dim\": 2}\n", "\n", "n = len(sample_dataset)\n", @@ -1077,12 +1146,12 @@ " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", "pos_rates /= n\n", "\n", - "print(f\"\\nPyHealth SampleSignalDataset built: {n:,} samples\")\n", + "print(f\"\\nSampleSignalDataset: {n:,} samples\")\n", "print(f\" input_info: {sample_dataset.input_info}\")\n", - "print(f\"\\n Label prevalence (multi-hot, threshold={50}%):\")\n", + "print(f\"\\nLabel prevalence (binary SNOMED-CT mapping):\")\n", "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", " bar = \"█\" * int(rate * 30)\n", - " print(f\" {cls:<6} {rate:.1%} {bar}\")\n" + " print(f\" {cls:<6} {rate*100:5.1f}% {bar}\")\n" ] }, { @@ -1096,7 +1165,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "2b1a0802", "metadata": {}, "outputs": [ @@ -1229,7 +1298,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "id": "036f2200", "metadata": {}, "outputs": [ @@ -1353,7 +1422,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "id": "90b71e50", "metadata": {}, "outputs": [ @@ -1561,7 +1630,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "id": "156a0428", "metadata": {}, "outputs": [ @@ -1910,7 +1979,7 @@ "Optimizer params: {'lr': 0.001}\n", "Weight decay: 0.0001\n", "Max grad norm: None\n", - "Val dataloader: \n", + "Val dataloader: \n", "Monitor: roc_auc_macro\n", "Monitor criterion: max\n", "Epochs: 5\n", @@ -1921,7 +1990,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Epoch 0 / 5: 100%|██████████| 2977/2977 [26:12<00:00, 1.89it/s]" + "Epoch 0 / 5: 100%|██████████| 2977/2977 [3:21:07<00:00, 4.05s/it] " ] }, { @@ -1937,7 +2006,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:27<00:00, 2.55it/s]" + "Evaluation: 100%|██████████| 376/376 [14:28<00:00, 2.31s/it] " ] }, { @@ -1957,7 +2026,7 @@ "output_type": "stream", "text": [ "\n", - "Epoch 1 / 5: 100%|██████████| 2977/2977 [26:39<00:00, 1.86it/s]" + "Epoch 1 / 5: 100%|██████████| 2977/2977 [4:54:27<00:00, 5.93s/it] " ] }, { @@ -1973,7 +2042,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:25<00:00, 2.59it/s]" + "Evaluation: 100%|██████████| 376/376 [03:21<00:00, 1.87it/s]" ] }, { @@ -1993,7 +2062,7 @@ "output_type": "stream", "text": [ "\n", - "Epoch 2 / 5: 100%|██████████| 2977/2977 [1:35:10<00:00, 1.92s/it] " + "Epoch 2 / 5: 100%|██████████| 2977/2977 [27:15<00:00, 1.82it/s]" ] }, { @@ -2009,7 +2078,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:21<00:00, 2.66it/s]" + "Evaluation: 100%|██████████| 376/376 [02:22<00:00, 2.65it/s]" ] }, { @@ -2029,7 +2098,7 @@ "output_type": "stream", "text": [ "\n", - "Epoch 3 / 5: 100%|██████████| 2977/2977 [26:02<00:00, 1.91it/s]" + "Epoch 3 / 5: 100%|██████████| 2977/2977 [26:09<00:00, 1.90it/s]" ] }, { @@ -2045,7 +2114,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:22<00:00, 2.63it/s]" + "Evaluation: 100%|██████████| 376/376 [02:23<00:00, 2.62it/s]" ] }, { @@ -2065,7 +2134,7 @@ "output_type": "stream", "text": [ "\n", - "Epoch 4 / 5: 100%|██████████| 2977/2977 [1:05:26<00:00, 1.32s/it]" + "Epoch 4 / 5: 100%|██████████| 2977/2977 [29:08<00:00, 1.70it/s] " ] }, { @@ -2081,7 +2150,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:26<00:00, 2.57it/s]" + "Evaluation: 100%|██████████| 376/376 [02:23<00:00, 2.63it/s]" ] }, { @@ -2175,7 +2244,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "id": "85ff3ccc", "metadata": {}, "outputs": [ @@ -2192,7 +2261,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Evaluation: 100%|██████████| 366/366 [02:20<00:00, 2.61it/s]\n" + "Evaluation: 100%|██████████| 366/366 [02:18<00:00, 2.64it/s]\n" ] }, { @@ -2209,7 +2278,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Evaluation: 100%|██████████| 366/366 [02:21<00:00, 2.58it/s]" + "Evaluation: 100%|██████████| 366/366 [02:19<00:00, 2.62it/s]" ] }, { @@ -2352,7 +2421,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "a8a558a0", "metadata": {}, "outputs": [ @@ -2376,7 +2445,7 @@ "Optimizer params: {'lr': 0.001}\n", "Weight decay: 0.0001\n", "Max grad norm: None\n", - "Val dataloader: \n", + "Val dataloader: \n", "Monitor: roc_auc_macro\n", "Monitor criterion: max\n", "Epochs: 5\n", @@ -2387,7 +2456,203 @@ "name": "stderr", "output_type": "stream", "text": [ - "Epoch 0 / 5: 17%|█▋ | 495/2977 [10:18<51:56, 1.26s/it] " + "Epoch 0 / 5: 100%|██████████| 2977/2977 [1:42:12<00:00, 2.06s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-2977 ---\n", + "loss: 0.4151\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [03:16<00:00, 1.92it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-2977 ---\n", + "roc_auc_macro: 0.7834\n", + "f1_macro: 0.4711\n", + "loss: 0.3601\n", + "New best roc_auc_macro score (0.7834) at epoch-0, step-2977\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 5: 100%|██████████| 2977/2977 [4:01:16<00:00, 4.86s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-5954 ---\n", + "loss: 0.3153\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [03:16<00:00, 1.91it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-5954 ---\n", + "roc_auc_macro: 0.8708\n", + "f1_macro: 0.5519\n", + "loss: 0.2958\n", + "New best roc_auc_macro score (0.8708) at epoch-1, step-5954\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 5: 100%|██████████| 2977/2977 [1:02:26<00:00, 1.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-8931 ---\n", + "loss: 0.2662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [03:15<00:00, 1.92it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-8931 ---\n", + "roc_auc_macro: 0.8856\n", + "f1_macro: 0.5766\n", + "loss: 0.2691\n", + "New best roc_auc_macro score (0.8856) at epoch-2, step-8931\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 3 / 5: 100%|██████████| 2977/2977 [1:17:11<00:00, 1.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-3, step-11908 ---\n", + "loss: 0.2452\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [20:33<00:00, 3.28s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-3, step-11908 ---\n", + "roc_auc_macro: 0.8987\n", + "f1_macro: 0.5840\n", + "loss: 0.2575\n", + "New best roc_auc_macro score (0.8987) at epoch-3, step-11908\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 4 / 5: 100%|██████████| 2977/2977 [1:28:51<00:00, 1.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-4, step-14885 ---\n", + "loss: 0.2272\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 376/376 [03:13<00:00, 1.94it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-4, step-14885 ---\n", + "roc_auc_macro: 0.9024\n", + "f1_macro: 0.6251\n", + "loss: 0.2495\n", + "New best roc_auc_macro score (0.9024) at epoch-4, step-14885\n", + "Loaded best model\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|██████████| 366/366 [20:27<00:00, 3.35s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " BiLSTMECG test ROC-AUC (macro) : 0.9155\n", + " BiLSTMECG test F1 (macro) : 0.6470\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] } ], @@ -4642,4 +4907,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From c4b86cc92bf47ea8be4304554851c72c4b3918bd Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Mon, 13 Apr 2026 08:09:00 -0700 Subject: [PATCH 03/10] refactor: align notebook with jtwells2's PTBXLMultilabelClassification design MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - SNOMED_TO_SUPERDIAG: use jtwells2's 46-code clinically correct mapping (from pyhealth/tasks/ptbxl_multilabel_classification.py) - Signal: full 10s at 100 Hz (decimate 500->100 Hz per jtwells2's signal[:, ::5]) → shape (12, 1000) instead of old (12, 1250) windowed slices - Schema: 'labels' key (plural) matching jtwells2's PTBXLMultilabelClassification output - Samples: 21,767 (1 per recording) vs old 152,859 (7 windows per recording) - SUPERDIAG_CLASSES ordering: [NORM, MI, STTC, CD, HYP] per jtwells2 - Cache: cinc_100hz/ instead of old windows/ directory - Fix: set dataset.refresh_cache=True to overwrite stale BaseSignalDataset cache - Update all downstream cells: split, DataLoaders, SparcNet, BiLSTMECG - Both models trained 5 epochs on CPU; pipeline fully validated end-to-end --- cs598_project/ptbxl_pyhealth_pipeline.ipynb | 886 ++++++++++++-------- 1 file changed, 552 insertions(+), 334 deletions(-) diff --git a/cs598_project/ptbxl_pyhealth_pipeline.ipynb b/cs598_project/ptbxl_pyhealth_pipeline.ipynb index 6084273a5..e31967755 100644 --- a/cs598_project/ptbxl_pyhealth_pipeline.ipynb +++ b/cs598_project/ptbxl_pyhealth_pipeline.ipynb @@ -586,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "f3bb5d93", "metadata": {}, "outputs": [ @@ -594,11 +594,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Step 4a: Generating ptbxl-pyhealth.csv (jtwells2 prepare_metadata logic) …\n", - " CinC root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", - " CSV already exists: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + "Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] …\n", + " CinC root: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", + " CSV already present: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", "\n", - "✅ CSV: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + "✅ CSV ready: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", " Shape : (21837, 10) (21,837 records × 10 cols)\n", " Columns : ['patient_id', 'record_id', 'signal_file', 'age', 'sex', 'scp_codes', 'sampling_rate', 'num_samples', 'num_leads', 'group']\n", "\n", @@ -702,43 +702,57 @@ "output_type": "stream", "text": [ "\n", - "SNOMED-CT code example (row 0): '251146004,426783006'\n", - "(comma-separated SNOMED-CT codes — no confidence percentages)\n", + "scp_codes example (row 0): '251146004,426783006'\n", + "→ SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\n", "\n", "Step 4b: Initialising BaseSignalDataset adapter …\n", - "──────────────────────────────────────────────────────\n", - " PTBXLDataset (jtwells2 CinC 2020 format)\n", - " Records : 21,837 (patient_id == record_id)\n", - " Label type : SNOMED-CT codes (binary, no confidence)\n", - " strat_fold : not available → random 80/10/10 split\n", - "──────────────────────────────────────────────────────\n" + "──────────────────────────────────────────────────────────\n", + " PTBXLDataset (jtwells2 :: CinC 2020 format)\n", + " Source file : PyHealth/pyhealth/datasets/ptbxl.py\n", + " Records : 21,837 (22 group directories)\n", + " patient_id : equals record_id (CinC format)\n", + " scp_codes : SNOMED-CT numeric strings (binary, no confidence)\n", + " strat_fold : not available → random split\n", + "──────────────────────────────────────────────────────────\n" ] } ], "source": [ - "# ── STEP 4: PTBXLDataset — updated for jtwells2's CinC 2020 format ──────────\n", + "\n", + "# ── STEP 4: PTBXLDataset — wrapping jtwells2's pyhealth/datasets/ptbxl.py ────\n", "#\n", - "# jtwells2's ptbxl.py (pyhealth.datasets.PTBXLDataset) now targets the CinC\n", - "# 2020 PTB-XL subset. It scans g1/...g22/ .hea files and generates\n", - "# ptbxl-pyhealth.csv with columns:\n", + "# ┌─────────────────────────────────────────────────────────────────────────┐\n", + "# │ SOURCE FILE: PyHealth/pyhealth/datasets/ptbxl.py (jtwells2) │\n", + "# │ CLASS: PTBXLDataset(BaseDataset) │\n", + "# │ KEY METHOD: prepare_metadata() │\n", + "# └─────────────────────────────────────────────────────────────────────────┘\n", "#\n", - "# patient_id = record stem (e.g. \"HR00001\") ← same as record_id\n", - "# record_id = record stem\n", - "# signal_file = absolute path to .mat file\n", - "# age, sex = from .hea header (# Age: / # Sex:)\n", - "# scp_codes = SNOMED-CT codes e.g. \"426783006,251146004\"\n", + "# jtwells2's PTBXLDataset.prepare_metadata() scans the CinC 2020 PTB-XL data:\n", "#\n", - "# KEY CHANGE vs PTB-XL v1.0.3 native format:\n", - "# OLD → scp_codes = {\"NORM\": 100.0, \"SR\": 0.0} (SCP abbrevs + confidence %)\n", - "# NEW → scp_codes = \"426783006,251146004\" (SNOMED-CT codes, binary)\n", + "# root/\n", + "# g1/ → HR00001.hea + HR00001.mat\n", + "# g2/ → HR01001.hea + HR01001.mat\n", + "# ...\n", + "# g22/\n", "#\n", - "# Since patient_id == record_id (no true patient metadata in .hea files),\n", - "# multi-ECG patient grouping is lost; split_by_patient becomes per-recording.\n", + "# Each .hea header contains comment lines:\n", + "# # Age: 56\n", + "# # Sex: Female\n", + "# # Dx: 426783006,251146004 ← SNOMED-CT codes, comma-separated (binary)\n", "#\n", - "# We use jtwells2's class for Step 4a (CSV generation) and then wrap it in our\n", - "# own BaseSignalDataset subclass for Step 4b (Trainer-compatible pipeline).\n", - "\n", - "from pyhealth.datasets import PTBXLDataset as JTWellsPTBXLDataset\n", + "# It produces ptbxl-pyhealth.csv with columns:\n", + "# patient_id | record_id | signal_file | age | sex | scp_codes | ...\n", + "#\n", + "# KEY DIFFERENCE from PTB-XL v1.0.3 native format:\n", + "# OLD: scp_codes = {\"NORM\": 100.0, \"SR\": 0.0} (SCP abbrevs + confidence %)\n", + "# NEW: scp_codes = \"426783006,251146004\" (SNOMED-CT codes, binary)\n", + "#\n", + "# WHY BaseSignalDataset ADAPTER?\n", + "# jtwells2's PTBXLDataset extends BaseDataset, which is the local PyHealth's\n", + "# polars-based dataset (Python 3.10+ required). The installed pyhealth 1.1.6\n", + "# on Python 3.9 does not have this class. We replicate prepare_metadata()\n", + "# inline (same logic, line-for-line) and wrap in BaseSignalDataset so that\n", + "# the SparcNet + Trainer pipeline works without modification.\n", "\n", "CINC_PTBXL_ROOT = (\n", " _PROJECT_ROOT.parent.parent /\n", @@ -746,49 +760,116 @@ " / \"training\" / \"ptb-xl\"\n", ")\n", "\n", - "# ── Step 4a: Use jtwells2's class to generate ptbxl-pyhealth.csv ─────────────\n", - "print(\"Step 4a: Generating ptbxl-pyhealth.csv via jtwells2's PTBXLDataset …\")\n", - "print(f\" CinC root : {CINC_PTBXL_ROOT}\")\n", - "jt_dataset = JTWellsPTBXLDataset(root=str(CINC_PTBXL_ROOT))\n", + "# ── Step 4a: prepare_metadata() — exact replication of jtwells2's logic ──────\n", + "# Source: PyHealth/pyhealth/datasets/ptbxl.py :: PTBXLDataset.prepare_metadata()\n", + "def prepare_metadata(root: Path) -> Path:\n", + " \"\"\"\n", + " Scan g*/: .hea files → write ptbxl-pyhealth.csv.\n", + " Logic is a direct copy of jtwells2's PTBXLDataset.prepare_metadata().\n", + " Adds extra columns (sampling_rate, num_samples, num_leads, group) used\n", + " by the Challenge data but not strictly needed for our pipeline.\n", + " \"\"\"\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\"\n", + " shared_csv = root / \"ptbxl-pyhealth.csv\"\n", + " cache_csv = cache_dir / \"ptbxl-pyhealth.csv\"\n", + "\n", + " if shared_csv.exists():\n", + " print(f\" CSV already present: {shared_csv}\")\n", + " return shared_csv\n", + " if cache_csv.exists():\n", + " print(f\" Using cached CSV : {cache_csv}\")\n", + " return cache_csv\n", + "\n", + " rows = []\n", + " for gdir in sorted(root.glob(\"g*/\")):\n", + " if not gdir.is_dir():\n", + " continue\n", + " for hea in sorted(gdir.glob(\"*.hea\")):\n", + " mat = hea.with_suffix(\".mat\")\n", + " if not mat.exists():\n", + " continue\n", + " rid = hea.stem\n", + " age, sex, scp_codes = None, None, \"\"\n", + " for raw in hea.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines():\n", + " line = raw.strip()\n", + " if line.startswith(\"# Age:\"):\n", + " try: age = int(float(line.split(\":\", 1)[-1].strip()))\n", + " except: pass\n", + " elif line.startswith(\"# Sex:\"):\n", + " sex = line.split(\":\", 1)[-1].strip()\n", + " elif line.startswith(\"# Dx:\"):\n", + " scp_codes = line.split(\":\", 1)[-1].strip()\n", + " rows.append({\n", + " \"patient_id\": rid,\n", + " \"record_id\": rid,\n", + " \"signal_file\": str(mat.absolute()),\n", + " \"age\": age,\n", + " \"sex\": sex,\n", + " \"scp_codes\": scp_codes,\n", + " \"sampling_rate\": 500,\n", + " \"num_samples\": 5000,\n", + " \"num_leads\": 12,\n", + " \"group\": gdir.name,\n", + " })\n", "\n", - "_generated_csv = CINC_PTBXL_ROOT / \"ptbxl-pyhealth.csv\"\n", - "_cache_csv = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\" / \"ptbxl-pyhealth.csv\"\n", - "csv_path = _generated_csv if _generated_csv.exists() else _cache_csv\n", + " if not rows:\n", + " raise RuntimeError(\n", + " f\"No .hea files found under {root}. \"\n", + " \"Ensure CINC_PTBXL_ROOT points to training/ptb-xl/\"\n", + " )\n", + "\n", + " df = pd.DataFrame(rows).sort_values(\"patient_id\").reset_index(drop=True)\n", + " try:\n", + " df.to_csv(shared_csv, index=False)\n", + " return shared_csv\n", + " except (PermissionError, OSError):\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + " df.to_csv(cache_csv, index=False)\n", + " return cache_csv\n", + "\n", + "\n", + "print(\"Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] …\")\n", + "print(f\" CinC root: {CINC_PTBXL_ROOT}\")\n", + "csv_path = prepare_metadata(CINC_PTBXL_ROOT)\n", "\n", "df_meta = pd.read_csv(csv_path)\n", - "print(f\"\\n✅ CSV written to: {csv_path}\")\n", - "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records × {df_meta.shape[1]} cols)\")\n", - "print(f\" Columns : {df_meta.columns.tolist()}\")\n", + "print(f\"\\n✅ CSV ready: {csv_path}\")\n", + "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records × {df_meta.shape[1]} cols)\")\n", + "print(f\" Columns : {df_meta.columns.tolist()}\")\n", "print(f\"\\nFirst 3 rows:\")\n", "display(df_meta.head(3))\n", - "print(f\"\\nSNOMED-CT code example (row 0): '{df_meta['scp_codes'].iloc[0]}'\")\n", - "print(\"(comma-separated SNOMED-CT numeric codes — no confidence percentages)\")\n", + "print(f\"\\nscp_codes example (row 0): '{df_meta['scp_codes'].iloc[0]}'\")\n", + "print(\"→ SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\")\n", "\n", - "# ── Step 4b: Wrap CSV in BaseSignalDataset for the Trainer pipeline ───────────\n", + "\n", + "# ── Step 4b: BaseSignalDataset adapter ───────────────────────────────────────\n", + "#\n", + "# jtwells2's PTBXLDataset(BaseDataset) uses the LOCAL PyHealth's polars-based\n", + "# BaseDataset. The installed pyhealth 1.1.6 has BaseSignalDataset instead.\n", + "# We bridge them with a thin adapter with the SAME process_EEG_data() contract.\n", "#\n", - "# jtwells2's class extends BaseDataset (YAML-driven, structured visits).\n", - "# Our SparcNet/BiLSTMECG pipeline uses BaseSignalDataset.set_task(task_fn).\n", - "# The two APIs are incompatible, so we define a thin adapter below.\n", + "# Schema stored per record (matches jtwells2's CSV columns):\n", + "# patient_id — record stem, e.g. \"HR00001\"\n", + "# ecg_id — same as patient_id (CinC format: each ECG is its own ID)\n", + "# mat_path — absolute path to .mat signal file\n", + "# scp_codes — \"426783006,251146004\" comma-separated SNOMED-CT string\n", + "# age, sex — from .hea header\n", "\n", "class PTBXLDataset(BaseSignalDataset):\n", " \"\"\"\n", - " BaseSignalDataset adapter over jtwells2's ptbxl-pyhealth.csv.\n", - "\n", - " Reads the CSV produced by JTWellsPTBXLDataset.prepare_metadata() and\n", - " implements process_EEG_data() so the existing Trainer/SparcNet pipeline\n", - " works unchanged.\n", - "\n", - " Schema change vs PTB-XL v1.0.3:\n", - " scp_codes — comma-separated SNOMED-CT string: \"426783006,251146004\"\n", - " (was dict {\"NORM\": 100.0, ...} with confidence scores)\n", - " patient_id — equals record stem (no true patient grouping)\n", - " strat_fold — NOT PRESENT in CinC .hea files\n", + " BaseSignalDataset adapter aligning jtwells2's CinC 2020 CSV format\n", + " with the installed pyhealth 1.1.6 Trainer / SparcNet pipeline.\n", " \"\"\"\n", " def __init__(self, csv_path: str, **kwargs):\n", " self._csv_path = Path(csv_path)\n", - " super().__init__(root=str(self._csv_path.parent), dataset_name=\"ptbxl\", **kwargs)\n", + " super().__init__(\n", + " root=str(self._csv_path.parent),\n", + " dataset_name=\"ptbxl\",\n", + " **kwargs,\n", + " )\n", "\n", " def process_EEG_data(self) -> dict:\n", + " \"\"\"Parse ptbxl-pyhealth.csv → patients dict expected by BaseSignalDataset.\"\"\"\n", " df = pd.read_csv(self._csv_path)\n", " patients = defaultdict(list)\n", " for _, row in df.iterrows():\n", @@ -797,25 +878,28 @@ " \"patient_id\": pid,\n", " \"ecg_id\": str(row[\"record_id\"]),\n", " \"mat_path\": str(row[\"signal_file\"]),\n", - " # scp_codes is now a SNOMED-CT comma-separated string\n", + " # scp_codes is a SNOMED-CT comma-separated STRING (jtwells2 schema)\n", " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", " \"age\": row.get(\"age\"),\n", " \"sex\": row.get(\"sex\"),\n", - " # strat_fold not available → splits will be random by record\n", + " # No strat_fold in CinC format — splits will be random\n", " })\n", " return dict(patients)\n", "\n", " def stat(self):\n", " total = sum(len(v) for v in self.patients.values())\n", - " print(f\"{'─'*54}\")\n", - " print(f\" PTBXLDataset (jtwells2 CinC 2020 format)\")\n", - " print(f\" Records : {total:,} (patient_id == record_id)\")\n", - " print(f\" Label type : SNOMED-CT codes (binary, no confidence)\")\n", - " print(f\" strat_fold : not available → random 80/10/10 split\")\n", - " print(f\"{'─'*54}\")\n", - "\n", - "\n", - "print(\"\\nStep 4b: Wrapping in BaseSignalDataset-compatible PTBXLDataset …\")\n", + " n_groups = df_meta[\"group\"].nunique() if \"group\" in df_meta.columns else \"?\"\n", + " print(f\"{'─'*58}\")\n", + " print(f\" PTBXLDataset (jtwells2 :: CinC 2020 format)\")\n", + " print(f\" Source file : PyHealth/pyhealth/datasets/ptbxl.py\")\n", + " print(f\" Records : {total:,} ({n_groups} group directories)\")\n", + " print(f\" patient_id : equals record_id (CinC format)\")\n", + " print(f\" scp_codes : SNOMED-CT numeric strings (binary, no confidence)\")\n", + " print(f\" strat_fold : not available → random split\")\n", + " print(f\"{'─'*58}\")\n", + "\n", + "\n", + "print(\"\\nStep 4b: Initialising BaseSignalDataset adapter …\")\n", "dataset = PTBXLDataset(csv_path=str(csv_path))\n", "dataset.stat()\n" ] @@ -847,7 +931,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "d2854a79", "metadata": {}, "outputs": [ @@ -855,25 +939,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "Type of dataset.patients : \n", - "Number of patients : 18,869\n", + "dataset.patients : \n", + "Total entries : 21,837\n", "\n", - "Patient ID : 15709\n", - "Number of ECG records for this patient : 1\n", + "Patient/Record ID : HR00001\n", + "# records for this ID : 1\n", "\n", - "Record #1 keys and values:\n", - " patient_id : 15709\n", - " ecg_id : 1\n", - " mat_path : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB/HR00001.mat\n", - " scp_codes : {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}\n", - " strat_fold : 3\n", + "Record field layout (jtwells2 schema):\n", + " patient_id : 'HR00001'\n", + " ecg_id : 'HR00001'\n", + " mat_path : 'g1/HR00001.mat'\n", + " scp_codes : '251146004,426783006'\n", " age : 56.0\n", - " sex : 1\n" + " sex : 'Female'\n", + "\n", + "Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\n", + " (comma-separated binary codes — no confidence % field)\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACAaUlEQVR4nO3dCbyN5Rr38cs8DyFThpTKkMiQpESJJOXQoCRFiYMMhZQQlVKSMp0KqTiGcxpEyJAkRIYMxVEpMjYhMu/9fv73+z7rfday9rz3Wnv4fT+f57P3WutZz7rXsxbPva/7uq87W2xsbKwBAAAAAAAAEZQ9ki8GAAAAAAAACEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkgFTzwwAOWLVu2OLeffvopaP/ff//dBg8ebLVq1bJChQpZwYIFrWrVqvbPf/7Ttm7dGrTviRMnbNy4cXb99ddb8eLFLXfu3HbBBRfY1VdfbUOGDLEff/zRsgKdQ+98Dh06NHC/d58+A0Texo0b3eehLfR7/vbbbwc+n2XLlqVpOz788MNAO5LznWrcuHHgfh3D/+83T548VrJkSatfv749/fTTtn///jR6FwAQXV999ZW1bNnS9TP0f1/p0qXtqquuskceecR+/fXXsP2eSy+91GJiYgKPTZw4MfCYrgN+p06dcn2ahg0bWtGiRd1rXHjhhfbggw+e0/8RPeYdK3/+/Hb48OGgx995552g/6+feOKJwGP6fz2+vlm4a5U29bPU36pdu7b16dPHfvjhhySfx2PHjtlLL73k+mp6n/ny5bNLLrnEOnbsaKtWrXLXxPjaFq6doUKPkStXLjvvvPPs8ssvty5dutg333xjGY3/e4WMy9+P8vqGkewTIuPJGe0GAFnNhg0bXIdv3759Qfdv27bNbeoMvfrqq+6+vXv32i233HJOx0L3a1PnUZ2QQYMGRfQ9AP6g1DPPPBP4A0B/QESDglJTp051vyclMJUY+iNKf4xpW7NmjY0fP94++OADa9SoUaq+DgBE05IlS6x58+Z29uzZwH0HDhxw29q1a61nz552/vnnn/O8HTt22KxZs6xdu3bxHv+vv/6ym2++2VauXBl0/88//+z+YJ0+fbr7fzyu4xw/ftz+/e9/W9euXQP3vfnmm5baTp8+bX/88Yfb1Gf717/+5YJfd9xxR6Ker/ej87h9+/ag+7///nu3KbDWu3fvVG/3mTNn7NChQ25TgG/y5Mn2yiuv2KOPPprqrwUAqYlMKSCVffbZZxYbGxu0eX+oHz161G677bZAQKpDhw5uBO7kyZOu86IsjAIFCrjH9Lw2bdoEAlL6g19BKGVOqUPz+eefW48ePQL7J5U6d+lNctrknePQ0disKj19rhrx9D4ffyZSRjJlyhTX0dcfXfr3JvpDpXXr1rZnz55oNw8AUs3LL7/sAlJFihRxgSP1N3bv3m0ff/yx3XvvvS6rKS7PP/+8+78+PgqOeAGpZs2auf7P33//be+++647tgYAlDH1v//9L85jTJo0KfC7+k0rVqxI1HvbuXPnOX2zcJSBrnOgwJIGXHLkyOGuq+3bt3eDMAlRxtg//vGPQEBKQbgtW7a4fp4yRnSOlYWla6K/LXpd/3UnoXaGUgaWXlv9y9dff91llel9KPg1b968RB0D6bOfpu+A/i1m9PeRGfqESDsEpYAIeuutt+yXX35xvyulWyNvF110kcuOUvr7sGHD3CbqBCoIJeXLl7dPPvnEpdCr41a4cGGXpaGOh1LLE5tCq4DZrbfe6qYL3nPPPe5xXRyUal+3bl0X4FJHRm3TqGcoBcjuvvtuK1OmjGuzfuqP8z///DOwjzJJFHgrUaKE26dSpUrWq1cv94d8uJRzZZ3oj32NvpYtW9Y9ro6VAnSaNqA2KTgXmlkW3/Q9L91fFz1l0FxxxRXufWm65NKlS8+ZSqnOpqZRaorWwIED3chraIqxOnfDhw930yzVJu1fpUoVF1hU1lp8/G184403rHLlypY3b16rV6+effnll0H7qlM+YsQIl36vdH+9zg033OBGsP28aQl6r3qsTp067ruhEd3UaEenTp3ceStWrJjLxtPnqaw9/35qg/6A8DRp0iQo7T6uVO0jR47YgAED3HdebdZ0g1atWtn69euD2pDYz1H7eFlS/veZWp0e/VGic6V/b94Ivr7zGoEGgMzCKwega7v6Afr/uVy5cq7fMG3aNDf9LK7/Izdv3mxz5syJ89gK4iv4JPp/XBlP6v/oOnffffcFMof0x/fo0aPPeb4CZer7fP3117Zp06ZAn0oqVKhgqSl79uzumCqz0K9fv8C1WX2AhOgcKLvKa5euXdWrV3f9oYoVK9pjjz3mrr9pQdc99ZvUp/KuT+rj6X3I/PnzA9fHp556KvA8BdF0n/o28QUEU7Mf6B3r2muvdd8BXWOV2RUXDQzdf//9rp/olbHQFEVl8fmpT6k+gr4rej8XX3yx3XXXXWGnhsbX36hRo4brH+mz++ijj4L2TWy/2T8VUQFNleHQe1U/MzHtmDlzplWrVs293wULFrjHVT5ApT60n+5X31n9eWXghbZR57NBgwauH6nXVZ915MiRgX3U1x47dqxdeeWV7j3ovejvjNBB3oTeh4Kt6h/qGPr/4oUXXgj73sL1Cf1/D+ic6t9HqVKlXL9Qn5v66H76O0bt1WejPqG+0/7+MDKwWAAp1rFjRw1lue2zzz6Lc7/mzZsH9vv3v/8d7zG7du0a2HfEiBHJbtuQIUMCxylWrFjg99tvv909/sADDwTuC91GjhwZOM7ixYtjc+fOHXa/nTt3un3mz58fmytXrrD7XHrppbF//vmn20/nKFybihQp4h5/5plnznl+mTJlAr/rPXm8+/QZeCpWrOjuK1y4cGy2bNmCjlOwYMHY33//PbBv48aNz3mtsmXLnvN5vvDCC3Gep7Vr18b7GXj7lShR4pzn5s+fP3br1q1uvzNnzsQ2bdo07GvofcyYMSNwzOuvvz7w/Dx58gT2Gz16dIrb4d83dNNrbd68OagN4TaZMmXKOefxr7/+iq1Ro0acx/7iiy+S/DnG1Qa1Lz763obb1/9vRu/B76uvvgo8VrVq1XiPDwAZSZMmTYL+f3v88cdjP/roo9hDhw7F2++555573M969eq5xyZMmHDO/6HTpk0L3NemTZtzjrdp06ag/kLodaBUqVKxjzzyiPv90UcfjT116lTs+eef724PHTo08NwBAwYEnuu/Rnn9lHD81yp//0IOHDgQdN3RdTo+XhuT2neL77oTF39fyt8HErVT7fUe379/v7u/S5cu7rb6ajrnM2fODOzz+uuvx/t6qdkP/OOPP2KLFy9+zj6lS5cO6keI2ql+QLhj6vtx8OBBt5/6SHH1B2bPnh3ve/O+Z+edd15s9uzZg56bI0cO9949ie03+/+N+Pu6vXr1SrAdRYsWDer3fPDBB7F79uyJveCCC8K+rtq9ffv2wHE6d+6cYL/ovvvui/N99OvXL1HvQ/8O9bnG12f3vhvh+oT+77D+Bgg9jv5v8ej9+fu72nLmzBn4f0DnDhkXmVJAKvNni2jTiI1H6eAejVjEx7/vZZddFvhdtRT8x9eoWGJp5EGjjCrA+eKLL7q0d29ERKNmmhb422+/uVEz0eiaN0qh19VIoah4p0a8NPLppYkrNtC9e3dXi0EjGBrVUV0Db/RTo296Xrj03//85z9uaqPaozYovV303jTiqJEwZSgllTJy9B7UDq/ull5HIyuiDCNvtOaaa65xGU8aBQqXLu9NEdB+GhFUbQyN8mlESNlEiaFzqZoZapeyoURTF5599ln3u0aOFy9eHBjt0+ekzDqNdKlNOpf+Wh/e85s2beqmWOj4bdu2TXE7RKPimu6g+/UZeedMUxC80WmdO00zCDd1NS6ql6YRdY2sqy6TRsX13dAoqY4dLvMvoc9Rr6epCx6vDWlRSFPZXZ7Qwu4AkJHpGu757rvv3LX49ttvd5kLmnrn9QFC6TFlpqju1Keffhp2H12jPOEyGpRFFG5fv4ceesj9fO+991xWiur8KXtLmRsJUbaOv++k7J7EUAa1srS8605o5kaopPTz0pKuscoSCm3XqFGjXIaa+mrKdFadMFE/wv/5h5Oa/UBlw3nnsm/fvm6/999//5zMJ1G/QP0AfUfUJ1S/Qf23nDlzuvflZf94/TS9P2XXq/+i7/Frr70W9P2Kj/p36h/r9bzMPvW7lL3vvUZi+81++iw0pVPH9c55fHQ+OnfubAcPHnTvRf1AHVvnW99HlfDQeVCGufqgareX/aY2etNcla2nffXd9bLcZPny5e7fkejY6msqG837zurffmhNtHDvQ+fIy67TsfWd0LH1eHIyFNV2ZYNptoD897//DSyioExF9RNFn5H394J/AQZkYNGOigGZgX8UIXSrWbNmYD+NPHr3b9iwId5jtmjRImiEJNwonDd6mNjRt9DsrIEDB8bZbm+bM2eOG53wbt90001hX2fbtm2Bfe64447A/ceOHQuMmtWuXfuckRG9H7/ly5cHHuvfv3/g/iVLliQ5U0rn5uzZs+6+b7/9NrDv888/7+4bNmxY4L558+YFnj9o0KBzRnO6d+8eGL3q06dP7OTJk2PXr18fGxMTE+/597exYcOGgfvUrpIlSwZGBsUbbY5v04ihfwRYI2l79+5NsA1JaYdMnTo19uqrr44tVKjQOVlKN998c2C/cCNf8T3WoEGDBN/j4cOHk/Q5hv4bTKzkZEopO8ufXQYAmYmu+VdddVXY/5uVkRTu/9zvvvsu9oknnnC/N2rUKGymlD/buG/fvue8rv7f9x7Ply9f4H7/dUDUp/IyQ/RTx/X3KeLKlArdvGzxhDKlxJ+l42XlJLXvFulMKfFnJa9ZsyZw/4oVK4KygZShsnv37nhfK7X7gTfccIO7rXYcPXo0sO91110XdC3Xc5WpFF+fwTvmSy+95G4rm6Zbt26xEydOjF21alXs6dOnEzyX3vesXLlyQf26unXrBtqptiS23xz6b0TtSAx/ptTx48eDHvNnH4XblMUk/jYqQzEc79+rtrlz5wbuf/PNNwP3v/baawm+j06dOgUeU//M06FDhyRnSvmzs9T/9+73+rgXXXTROX1CKV++vLufTKmMjUwpII0LnfsLY/rrHoQbgfDzj+r45/hrzrWOm9hRH7+aNWsG3U7M6IJGPfz7xZWxpJEij2pgeTR6pqKecb1eaJv89ZlUMyDc74mlER2NvIhG7TzeSIv/tTQPPtzvHo2SqfaBRq80wqeaS1ouWqNKic2Y8Z8XtcuroeWdu8R+Hn6qJ6CaDkmRUDuUwaTMo9WrV7uMsNDMp5QUU0/Me/TXpkjM55iQ0OW1/fXHksr/b5H6BQAyG9X3Uz1LZWQoY1YZNJ7Q2jp+ynbR9V5ZEuGKj/uvO/5sonD3+feNK1tK1wllyiT2//PQQueqG5QYytrwsj5Um8frz8R1XUlKPy8taYEOvWePv8/YsGFDVw/Jo/pP4fo9fqndD/T6X8r68S/YE9rX0+ccmiEeV79ItZb0/VU214QJE1xml7KA9N41SyAxdB68upjebVG2jtqSnH5auL5uYrKy/f0dSei1vddNyWfl/z3SfXZ/zbr4+uzqs3p9wuS+FtIfglJABGkVFo/SicPxLr7+fRWIUjp0SqkwoZ9/aedVq1adszKNLsIKTvj327ZtW9hjq6Clxyvm7gUwvFRm/z5xtckLkIh/dbPkrHSmAt0efycj3Gv5L6zhpg5o+sIXX3zh3pumjSkFXR1UBSmee+65RLXHf1ydW+81vfPiP89K1w73eYROUwg9f6nRjtmzZwceV8F9dfAUnAon3HmNj/ceVWxfxw33HkMDrgl9jslpR3Jp+qFHhT0BILPw/z+v66NW3NMULE39j+uPbf//7Q8//LD7fcaMGec8rmuXppSJrqGhgw+aUu7R4h5xUVF077qnAISuzZH6P7958+ZBfwyHE9p3CzflMaEgS2rQNHtN2RIFoDQN0aOFQVSM3KPgo7cqYlxSux/o9b80BUulCuLq62lqmve90fkP7TNo8wr0K/ilQvOa8qZSCJpWqNdRHye+4uJ+/nb7b+tz17+DxPabQyW1rxZuf++1VdIj3Hnwprml5LPy9w/Ta5/d6x+Haz8yLoJSQARphM8bdVEHQPP5NZKlgJOCG8rG8eatq7PljWRpH81XVy0e7auLRmosD9uiRYugUU7NvVcHShd4Xcy9EVKN2HgjGKoXoUwhZQxpBFGjUeoAaB/VbPACGeoQaHRRNYC8gJq/sxYXraahYI9odUJlmun4iQ38JIUynzyan67X0ao+/iWnPVotR/PvdX5UN0yrgngd9cTOZ9dnrtVU1PFXDQS9nuh4oZ/HI4884kaO9Xr6XLTctrdiYkol1A5/BpI+C33XnnzyybDH8s6BaHWbhJav9t6jOsuqPaH6ETq+6kSo0+jVnkgqfzv078QvtOMWurJMQvQHhJYuV90UnTfv9RJa+RIAMhL1O9RP0eqmChbo/2ZlFOl6n5gaSVqpTiuChQu6KJtBq9WKav0o4KW+jV5DASkv+KMMifiuA0WLFnX9CtW6Sqv/g/XHvf7QVQ0br8al3pdX0zC+64qyjrQ6mCiLWn23b7/91vWDdE3X8bRqXFpQO3Q9HzdunFvFzPvj3lvVWdR/1Ep4XluVSeMFUvS5xCW1+4HK1hK9tmolaT9laYdm2SkI4g3G6XXVF1PfRZu+p/pOKagmqk+qFYgV8FT9T/XTvCyaxPbT9Llr5UIdX30+L8Oqfv36LuiV2H5zWvBeWxl4Wllb71OfmYJj6k+pHystW7YMPEd9N51T7ac+mj6r0P64+pcKIuk9eKs26nvTrFmzBNvkfY7yzDPPuDZpAFf1wdKqz67vnM61PqMxY8YQlMosoj1/EMjsNaVCa+2oDpF/dZHQzb8qx65du4LqUIXbklJTKtzqM/GtIuKfn52YVVdUl0krYYTbp3Llym61ldA55OFqJ/hX0vE2/yotia0p5a8T5K8f5H++f7Uhb/PP21+2bFmCn7HqZ8TH2y/c567aGf7V92688cY4X8f/frxaGUmZQ5/Ydvjn/XvbxRdfHLYd+o6GfuZezapw9QOOHDkS5+p7Kfkcp0+ffs6xnnrqqRTXlAq36buo2mcAkJnUr18/zv/3VFNn0aJFcdaU8niru4W7xuv//2uuuSbO11AfI7T2ZWhNqXCSU1PK33cJd80LvT4mtHqb308//RR72WWXJaqeVWrVlAq3qRaTVxdIVCvJ62OoJte+fftcjSCvvtQ///nPeF8vNfuBqs/oX8nNf331fvd88803ca6+5z9f8V27/d+LcLzvmVYnDm2/zk9iV9/z98mSU+syXL/H88svv8S5+l5onygxq+/FV8fUX/ctvvcR1+p7/s8xsTWl/N/7cH+7xLX6nrei9IUXXpjo84z0h0wpIMI0gqZMDo0cKStIc+k1+qJ0XM1/9+oleHO7tZqNpopplEar2yiNWXPzNQqkERCNFKXE5MmTXYp5vXr1XDu0aTRMo0/eiIrceOONrs6ERp6ULq9aDvqpkTZvZRpNZ1I9iVtvvdVlkmgf1Vfo0aOHG8nxZ7PER9liOj9KN1d7NHqrEbS0oKlqykDS56BUZY0u+ldG8VbW06p2eq/6TDSSq/esz3Ls2LHuc0sMpZ5rNFUrzWnUtU6dOm7kr1q1au5xfbaffPKJWxFPK4/odZSppJFMZU6lVrZYQu3QiKlW4lNWn0Ypb7rppjhXVNL50Mil6j7p806I3o9G7QYMGOBGVfX6GvnWvwWNemvkMTn0vdTob1LrayU2pVzp8FdddZX7bmq08brrrkv11wGAaNL/+926dXN1Y/R/nv5P1zVQ1wxdAxKTBaL/2+O6Fuj/f9XdVJaDav3otv5/1XVE151169ZZu3btLNq8961rvK5L+j//jjvuSPTzvRpGykTWdUPvU9dzXSfVt9I5SgvqQ6hvUr16dZeNpQxkf39GGVRatU6U6aQVjq+++upAxpn6fIsWLYrz+KnZD9T5VVuUaZMnTx6XYaXX1/NCqX+g86lzpylc3uuqH6wsHy/rR99PtU3HUt9RZQLUr1GmmH914fjo3Kl2Wo0aNVz/RP0vrQCn957UfnNqU9aXzoNqZ+k7pn876rdqVoX6zPfff39g3zfffNNN4dTnq/Og75/+zvBneikTTBmK+veux9Xf07E0W0CrNCaG2rBw4UL3GegY6oMpY0ptTG3qM2rqr9qrz0aflf428FYhT+xK2EifsikyFe1GAEC0KOinDrF3UdN0Al1cNZ1SQTHVIvDqGSSXNzdene6kTh1LTemlHQAAAOmFFi7R9EpNFVy2bFm0m4M4qMadas4pKCWa+qs6cwpnaFDZm26LjCfhYW0AyMQ0IqQaBBpt0uibahzp4qailipGn9KAFAAAAICUad26tatDpkw51SHzVsZUULF///7Rbh5SgOl7ALI0jbgovVmFWbVErqYs6KL3+eef29133x3t5gEAAABZnjL9NXVRqzlqUR5NSVTZB01r9K8wiYyH6XsAAAAAAACIODKlAAAAAAAAEHEEpYBkUpJh7dq1XfForcAWSqtR/OMf/3ArhWhlEf3UVDHVL9JUMWncuLF7vuZCp4RWQ2nfvr1b4USvpRRWrUqi1TOOHTtm6YWKRw4dOtRthw4dCnpM9+lcaPvpp5/StB0q8q3X06ojSaF2eW3U8xN6DW9fimamPf0b0rnWv6lIfJYHDx50K9Wo9phWOAIAJK+/JD/88IN7XKsKi1bw0u0dO3ZYRrzGpIakXKeS4oEHHoi3r6Vam3rcW3W3SZMmbjXexPDaq001ObXyoFYdbNOmjc2dO9fS6hzpPWW0Pllafb5J/R6n1t8iCdHK43odrVa4b9++NH0tZDwEpYBkmjlzpvtjVAWyO3fuHNT50pLKWsHtww8/dP/xnjp1yv3UUshdu3a1v/76K9XaMWLECLe0slag2L17t3utX3/91S29+/jjj6ebDp2oI6COprbQoFQkqXOiNiQ1KAV4FPh98MEH3b93748oAEDi+0t+X3zxhft57bXXup+q66hVcS+55JKIthX/97NQQEl9S9XtWb16tV133XVJPo4KUh89etR+/PFH++CDD6xVq1Z277332pkzZ9Kk3UjfatSoYS1atLDjx4/bsGHDot0cpDMEpYBkeuWVV9zPdu3auYwJz5gxY2zixImBP1z/+9//umwlBWHmzJnjMpj8QRr9UZvczCBd5PUHsY6hkQeNbul11AlYsmSJ3XLLLZZRaJRI70NbWo/WJJfa5bUxUqNa0aAOQ3qj7EIFXNPTZ6mCm94Sxdu3b0+1tgFAVugvhQZClHmqPpL+r09uICQziVafQ5/FFVdc4bKc1qxZYydOnEjyZ6Fi1Gr34cOH7aOPPrKLLrrI3f/vf/+bgZx01odL6d8iyek3aXA4moPTSH8ISgHJsHXrVlu7dq37/Y477gjcr9Gf5557LnB76tSpLmVZAaMiRYq4UaIVK1a43+NKmfXSqrVt2bLFbrrpJvd8XdBDM3uU7ePRVL1OnTq5YxcoUMBNFZw3b54bmQhNE04ozdm/75AhQ9x7Kl++vOtMKo3722+/Deyri4qmDlatWtWKFi1quXLlcqObOi86Tx69R397K1WqFPTe45q+t3//fvvnP//p9sudO7dbHe+ee+6x77//PqjN/vf2xhtvuNFVnQd1cDdu3Bj0vjQCKz///HOiz0noefF3ELUKiEb/1IFT+/r165eqAZS0oo6I937Gjx9vPXr0cO3XVFOPgpvNmze38847z00N1Uonzz77rJ0+fTroWJrO1qtXL6tcubLbr1ixYtaoUSPXofXs3bvXunTp4r5L+iwVtL3zzjuDvifi/0xee+01993X/t73btasWa4defPmtfr167s/XpIqNT5Lvbbei9fBAgAkrr8Ueg2aPHmyy6zxrjX6w3r27NmJvj4rM/3GG290/RBdG3Td0KpcfgqIqE9QsGBB159R4EUBM6+kgicp15jEXCM1MPnYY4+5aWx6XbVRfbOHHnoo3gBCXNepxPR3ksrfB1NmkzLb9Luu49K9e3d3O6nXusKFC9ttt93mBmWVfSW6rmu1Y/UJ1FfQcRX08tbe0uCu15b33nvvnHORmO9DfDRbQf3K4sWLu37II488Yn///XfQPpplcP/997v+kPofF1xwgeu/HDhwIGg/9bv1PdL7UP9X2YAaEP7yyy+D9tN3++mnn3b9Y31W+tsgrilsOg8a3K5bt67bV38DaJVofS/9/H8v6HO//vrr3fdr4MCBSTofKf1bJCl9xVtvvdU9rkCnMiiBAK2+ByBpxowZoytnbI4cOWL//vvvwP2rVq1y92urUqVKgse5/vrr3b4VK1YM3NexY8fAMYoUKRL43dsWLlzo9tu3b1/gvkKFCsWeOnUq3tfauXNnYH+9RmL3LV68+DltKFmyZOyBAwfO2Td0K1asWGA/vcdw+3jvfciQIYH7dEzZs2dP7AUXXBD2eeedd17s9u3bA22O75zpNXR+4mtrQuck9L2qvZ4mTZqcc7wyZcoEfv/ss89i0yO1y/9Z+c+hTJkyJTZbtmxhz1fLli1jY2JiAp9T+fLlw+6nY8ju3buDzol/y58/f+yaNWsC7QrXJm0bNmxwbQ5tU8GCBd2m3/VvKjFS67O866673P1169ZNlc8EALJCfyn0GhTfltD1efjw4fH2L2TQoEFxHv/OO+8MalNirzGJvUZ27do1ztf+9ddfk3ydSkx/J6n8fbD4Nu+aHpdw597TokWLwOMzZ850902fPj1w34QJE2J//PHH2AIFCrjbbdu2DXsuEtNfC6V2+/uwoe9r4MCBgX03bdoUW7hw4Ti/UwcPHjzn/YZuefLkid28eXNgv2eeeSbevoX/833ggQfiPO7IkSPD/r3g7y/16tUrzvPg9cX93+OU/C2SlH8Hnquuuso9dscddyT5c0TmRaYUkAzr168PZPv4U9GVeePRKEFKNWzY0I3KzJ8/P3CfRg5DX0sjFxqhSQsaPVq0aJHLiNJImZcV442UaFREUxRVz0ojH5o6+Oabb7rH/vjjD1fryhvlUtaVZ+fOnQmmCw8ePNj27Nnjsr+U3aTj69xrROrPP/+0p5566pznKFVcr6/2eqNpOlfK2PFS4TWa5E8v15bcTJelS5e6WmGiEUVldm3atMmNLiWWf0Qqri10SqNXrDK+LSmjiRqt/c9//uM+P2Xz6Wfv3r3duVENAH2++i48//zzbn9l4X3yySeBz0mPe9Mzdu3a5T4fjVxrZNjbxxsVVB00fU4zZsxwt3VcvVYofX/0PB1L3xd9z3VbbdL706ihjqMRT7U3pZLzWXqZiBql1EgoACDh/pKXoaH/z72C2m+99Za7rWxV9WmU0ZLQ9Vl9CC+LSBlIysjR9UBTqnv27Onu1/VD1x1RVtF3333nrkfelDT1q9TPkcReY5JyjdQ1VZQZrOfpmqY+iV5LWSPJFV9/J7klFLypdcpG121lCClLx+srpSRL6dJLLw387vX9lPl+1113ud+feOIJ69Chg8ssK1WqVKAURmpT9pGyf1RcX5lL/r619OnTx44cOeL6iMoYU99TmUA5c+Z053fkyJGBfadNm+a+X/rs1Y/y+uuqxaXvs/c5vfzyy+53vZ6Oqb69ZhiE0nfF+76rj6vnKqtMCyeJvjPK6A6lvpa+82q3971PLfH9LZKUfweh/aZ169alajuRwUU7KgZkRN5oT/369YPu18iPNzpw++23J3ichEYntm7dGrjfG9lp1qyZu/3VV18F9qtZs2aqvj//iFT79u0D9x85ciQwGnL11VcH7h81alTslVdeGRjd8m8aIfSEy4aK77G4Mmv8I0Me77569eoF7vvkk08C92s0Lr7zntTz4o1qDRs2LHCfXs/z9NNPJzpTyv+Zx7WFtjWuzDP/ltBoon+U+pFHHgl6TKNgCR2/b9++QZ+TRtNCR8I9pUuXdvuUKlUq9uzZs4H7GzZs6O7X9+rQoUPuvriyDc+cORObK1cu95hG2jx6zdy5c58z+heJz1Iju95j/tFTAEDc/SW/J554wu2jLBnvmnLNNdck6vj/+te/Av8HP/fcc2H3mThxYmCfsWPHBu5ftGhR0PUsKdeYpFwjlS2i22XLlnXv9d133w3q3yU3Uyox/Z2kUt+uQoUK7vdt27a54z355JOJfn5cfRbp2bNn2Iyf33///Zz+3pw5c2JTkz9Taty4cedkO+vzlWPHjrmsvvg+19q1aweeP3XqVHfONGMhNFvo5ptvdvssX748cF///v0Dz12yZMk5n68ythL6Xnnnxt931EyNxEhOplR8f4sk5d+BZ8CAAYEsecBDphSQiipUqBD4PTUKH/tXnVFtA2/0JfS1NP8/rVYz8WrmiOrsePWwNHIjo0ePdrUSNPKj0a3ULJqtVQTjo0yaxJwz/3lLbaqJ4NGIYrjfE6JRMW8UMq4tNKNMtxN6TlKyv2rWrJmkc+8//96+GlWMq4it931RfQYVsw39fqm9oaN/qtMQegyvPoH//Oo1lT0Xjc+S7CgASDp/jaAXXnjB3adsWN1WFtPKlSvPWbo+HP+1Klzmif/6E9qn8f+u4yTlGpOUa6SyZJQdomuM3quygapXr25XXXVVioo9p1Z/R30F77NQ/SxlO+v3KlWquMeV9RJa1yo5/ve//wV+92d/69zed999QY+l5UI94c6bVztSWWyhNcbi+ly12JAKd+uceVl94fq/SelbJOV7FV8fLjXF97dIctpLvwnhEJQCkkGFESX0j2gVJVSRQ9m2bVsgJd3PCxgkhn9KXugUIqUAexchXQxVJDSchC6uCfGmZXmvo1Ri8d6nl8KrC9VXX33lgmObN28Oe6ykTGkTFZr2pkKGC7qEu7DFd86S2474+IuCa6phuN8zwvS90GCSd+5F0x7CnX/vO+ftq7R2pbmH431f1Dnzf/+975faq6Kj8bVJx/A+X//51WuG66RF4rP0/g9QWn9qBMYAICv0l1KL/1qlfld81x/55ZdfwvZvtE9SrjFJuUYquKOp4Jou9vHHH7vgjop+qwD8uHHjkv3eE9PfSU8F7xcvXhzoL2oxHv/nNnbs2KCA5UsvvZRmbYnvvOk67hVkV+HucJ+rBoJDp/zpc1VgS/3klPQt/N+rVatWhe33eivY+cU1IJjW5ysp/w483v8FmqIJeAhKAclQu3Zt99ObR+7RH6b+OkdauUN1dbSP5nnroqXVUbzATkr5azQpW0mjXXodZSypPo5GmrwAUXJXLtFIkI6lNmtFDy+goFX4/KMlOq4yqTTqF9domupPeTSfPyGan+5lnemYGsHSudSFWvWtXnzxxUS/j3Dt0Kio6galdK69RyOgmnevcz5p0iTLyPQ99bLitDqRai3ps1Y9MdXZUM0lr65Zy5Yt3U99R7SakDr9+h7OnTvXli9f7h67+eab3U+dH3U21XFTh06j4aKaFd7rxUUdRe0n6szr+Xod/TtIjdUOk/NZev++atWqFejIAgDi7y95NR69QJJqGem2t3KY/vDXba3QFx8FDtT3El1bVMNGfSAFgLQqsWjlMC9DVyu/KWNH136tDubRNSop15ikXCNVg0h9KbWzWbNmrraUl3GSmEyTtKY+obfim2hAVbcbNGjgsvK94EJyMqV0rVffVyvweYOkWqnXG4TSQKb6ysoq0mupLqXonPsHOFNz9b34KLjj1R3VedDqhnoP2tQXVpab6kiFZqSp/6vgpVeTKzTrW4/LO++842pQ6nviX607tN8rWj1S9c/03dO/h9dff92aNm1q6UlS/h14vM+1Tp06UWkz0qnARD4AibZly5Y4a8xolYn4VlrR9ueffyZqHndC88BFNRTiWvXCW7EsJavvhavr5F99L9yKLRdffHHY11q5cuU5+3o1q8LVlPrll1/iXH0vrhoL/tfz10zyrxjz/PPPn3OsN998M9n1HRo3bnzO8fyrFmaE1ffCragzefLkeL9b3ue0d+/eBFff+/nnn109qXD75MuXL3b16tWB143vexpuZaS8efO62gTh/n2k9WdZrlw5d7/qhAAAEt9fEl179diCBQvc7euuu879v5oUiVl9L75aPW3atEnWNSax10ivrxdu89cvTGpNqcT0d5JC/bGcOXPGHj16NPb48eOuztJ9992XpGPE1/fVdu+998aePn06sL+/lqO+A+ofq/aWbteqVSuwkmBqrr7n/x6G63N/8803ca6+5z+//mOG6//6vytDhw6Nt2+R2NX3EvP3QmrXlEro+Yn9dyD6bnn12VTrDfCQKQUkg1cLQLRimZ9GcSZMmOBWqWjdurVLT1Xqq6bbqTaCHvNGTFKDRmWUbaIVTMqVK2e5c+d2Kega7dOooX8ueHJ06dLFjfKp9oJWidF70GiRl5KvUU2tvKHbBQsWtDvuuMP+/e9/hz2WRt1Um0DH8tcViovm23/99ddu5RvVK9J51HvTNMlBgwa50bXk0MokGu3yp/SnhL4DGt3Tii4a/Xv00UeDRmAzqgcffNCtSKSRaGWX6bulkUxl4GnFHy8lvUyZMu5z0vtWTRDtp1WQtLJRtWrV3D56nvbp3Lmz+1w1Yqzz37ZtW1ePoX79+olqk75/+n7pe63X0UjbwoULg1LII/VZqt3eVJC0HLkFgMzYX5IvvvjCZSgp40IZIcpQ8lbFSyz1B95//32Xwa2sDV0btNqft2KZqO+hLBVda/Lnz+/6M5dffrnr38ycOTNZ15jEXiN1fVCGlG5rH00RU39IK9D6M2OiTZ/FlVde6a5/WsFPn0dSP4vQ/rCOpX5BmzZtXPa0soy8zDbVIh0+fHjgHOk8qu/wr3/9y92njKJnnnnGIk2ZTeqvqJ+oz0ztVV9e31F9j7zMb02jU/9AfW9lWCkjL1zZDnn66afd91R9ZX3/WrVq5bLnwtF0N2Wt1atXz+2rTd9HtUd/Q6Q3if134J/mqPPlZcUBkk2RKU4FkHTqTCgQpD9cVRRSF43MQmnS6tB5KdQpLW4JZEbdunVzHUf9URG65DEAIPP3lwAknvpLCxYscP2n8ePHR7s5SEfIlAKS6e6773Z1ZFSwL64i4wAyJ9UB8VYsClcXAgDwf9FfAqBaUgpIKUtKmWOA3//NnwSQZPpjVKnHyDziW71GadoKQiBjSOvPUlM5vOWeAQBxo78EoEaNGolefRxZD0EpAOfwVsUBAAAAACCtUFMKAAAAAAAAEUdNKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARByFzlNJTEyM7d271woVKhTvqk8AACBjUznOv/76y8qWLWvZszO+lxT0lwAAyBpiE9lfIiiVStTBKl++fLSbAQAAImT37t1Wrly5aDcjQ6G/BABA1rI7gf4SQalUohE/74QXLlw42s0BAABp5MiRIy6w4l37kXj0lwAAyBqOJLK/RFAqlXgp6Opg0ckCACDzY/pZ0tFfAgAga8mWQH+JQggAAAAAAACIOIJSAAAAAAAAiDiCUgAAAAAAAIg4glIAAAAZ3IUXXuhqNoRu3bt3d4+fOHHC/V68eHErWLCgtW3b1g4cOBB0jF27dlnLli0tf/78VrJkSevXr5+dOXMmaJ9ly5ZZ7dq1LU+ePFa5cmV7++23I/o+AQBA5kJQCgAAIINbu3at7du3L7AtWrTI3X/nnXe6n3369LGPP/7YZs+ebZ9//rnt3bvX2rRpE3j+2bNnXUDq1KlTtnLlSps6daoLOA0ePDiwz86dO90+TZo0sY0bN1rv3r3toYcesoULF0bhHQMAgMwgW2xsbGy0G5FZljssUqSIHT58mNVkAADIxDLCNV8Bo7lz59qOHTtce88//3ybPn263XHHHe7xbdu2WdWqVW3VqlV29dVX2/z58+3WW291wapSpUq5fSZOnGgDBgywX3/91XLnzu1+nzdvnm3ZsiXwOu3atbNDhw7ZggULMs25AwAAKZfYaz6ZUgAAAJmIsp3ee+8969Spk5vCt27dOjt9+rQ1bdo0sE+VKlWsQoUKLigl+lmjRo1AQEqaN2/uOpRbt24N7OM/hrePdwwAAICkypnkZwAAACDd+vDDD1320gMPPOBu79+/32U6FS1aNGg/BaD0mLePPyDlPe49Ft8+ClwdP37c8uXLd05bTp486TaP9gUAAPCQKQUAAJCJTJo0yVq0aGFly5aNdlNsxIgRLnXf28qXLx/tJgEAgHSEoBQAAEAm8fPPP9vixYtdAXJP6dKl3ZQ+ZU/5afU9PebtE7oan3c7oX1UJyJclpQMHDjQ1ZLwtt27d6fSOwUAAJkBQakMIiaGevQAACRFVrx2TpkyxUqWLOlWyfPUqVPHcuXKZUuWLAnct337dtu1a5c1aNDA3dbPzZs328GDBwP7aAU/BZyqVasW2Md/DG8f7xjh5MmTxx3Dv6Wl2JgYS4/Sa7sAAIg2akplENmzZ7OXFuyz3X+cinZTAABI98oXy239bi5jWUlMTIwLSnXs2NFy5vz/XTxNm+vcubP17dvXihUr5gJDPXv2dMEkrbwnzZo1c8GnDh062MiRI139qEGDBln37t1dYEm6du1qY8eOtf79+7si6kuXLrVZs2a5FfnSi2zZs9tvs8fY6YN7LL3IVfICK3Fnr2g3AwCAdImgVAaigNQPv/7/YqEAAAAeTdtT9pMCRqFGjx5t2bNnt7Zt27rC41o1b/z48YHHc+TIYXPnzrVu3bq5YFWBAgVccGvYsGGBfSpVquQCUH369LExY8ZYuXLl7K233nLHSk8UkDq1b2e0mwEAABKBoBQAAEAmoGyn2NjwUxbz5s1r48aNc1tcKlasaJ988km8r9G4cWPbsGFDitsKAAAg1JQCAAAAAABAxBGUAgAAAAAAQMQRlAIAAAAAAEDEEZQCAAAAAABAxBGUAgAAAAAAQMQRlAIAAAAAAEDEEZQCAAAAAABAxBGUAgAAAAAAQMQRlAIAAAAAAEDEEZQCAAAAAABAxBGUAgAAAAAAQMQRlAIAAAAAAEDEEZQCAAAAAABAxBGUAgAAAAAAQMQRlAIAAAAAAEDWCkqNGDHC6tWrZ4UKFbKSJUta69atbfv27UH7nDhxwrp3727Fixe3ggULWtu2be3AgQNB++zatctatmxp+fPnd8fp16+fnTlzJmifZcuWWe3atS1PnjxWuXJle/vtt89pz7hx4+zCCy+0vHnzWv369W3NmjVp9M4BAAAAAACytqgGpT7//HMXcFq9erUtWrTITp8+bc2aNbNjx44F9unTp499/PHHNnv2bLf/3r17rU2bNoHHz5496wJSp06dspUrV9rUqVNdwGnw4MGBfXbu3On2adKkiW3cuNF69+5tDz30kC1cuDCwz8yZM61v3742ZMgQW79+vdWsWdOaN29uBw8ejOAZAQAAAAAAyBqyxcbGxlo68euvv7pMJwWfGjVqZIcPH7bzzz/fpk+fbnfccYfbZ9u2bVa1alVbtWqVXX311TZ//ny79dZbXbCqVKlSbp+JEyfagAED3PFy587tfp83b55t2bIl8Frt2rWzQ4cO2YIFC9xtZUYpa2vs2LHudkxMjJUvX9569uxpTzzxRIJtP3LkiBUpUsS1uXDhwmlyfh6d/rP98OvJNDk2AACZycXn57HX7q2YJseOxDU/s4rEuds3rr+d2rfT0ovcZSpZme4jo90MAADS5TU/XdWUUmOlWLFi7ue6detc9lTTpk0D+1SpUsUqVKjgglKinzVq1AgEpEQZTjoBW7duDezjP4a3j3cMZVnptfz7ZM+e3d329gEAAAAAAEDqyWnphDKTNK2uYcOGdvnll7v79u/f7zKdihYtGrSvAlB6zNvHH5DyHvcei28fBa6OHz9uf/75p5sGGG4fZWaFc/LkSbd5dCwAAAAAAAAkTrrJlFJtKU2vmzFjhmUEKtKuVDRv01Q/AAAAAAAAZKCgVI8ePWzu3Ln22WefWbly5QL3ly5d2k2tU+0nP62+p8e8fUJX4/NuJ7SP5jXmy5fPSpQoYTly5Ai7j3eMUAMHDnTTDb1t9+7dKToHAAAAAAAAWUlUg1Kqsa6A1AcffGBLly61SpUqBT1ep04dy5Urly1ZsiRw3/bt223Xrl3WoEEDd1s/N2/eHLRKnlbyU8CpWrVqgX38x/D28Y6hKYJ6Lf8+mk6o294+ofLkyeNew78BAAAAAAAgA9SU0pQ9raz30UcfWaFChQI1oDQdThlM+tm5c2fr27evK36uwI9Ww1OgSCvvSbNmzVzwqUOHDjZy5Eh3jEGDBrljK3AkXbt2davq9e/f3zp16uQCYLNmzXIr8nn0Gh07drS6devaVVddZa+++qodO3bMHnzwwSidHQAAAAAAgMwrqkGpCRMmuJ+NGzcOun/KlCn2wAMPuN9Hjx7tVsJr27atKyyuVfPGjx8f2FfT7jT1r1u3bi5YVaBAARdcGjZsWGAfZWApANWnTx8bM2aMmyL41ltvuWN57r77bvv1119t8ODBLrBVq1YtW7BgwTnFzwEAAAAAAJBy2WI1hw4pptX3lNml+lJpNZXv0ek/2w+//v8V/wAAQHgXn5/HXru3Yoa95mdWkTh3+8b1t1P7dlp6kbtMJSvTfWS0mwEAQLq85qeLQucAAAAAAADIWghKAQAAAAAAIOIISgEAAAAAACDiCEoBAABkcHv27LH77rvPihcv7lYwrlGjhn399deBx1VCVIu5lClTxj3etGlT27FjR9Ax/vjjD2vfvr2r+1C0aFG3AvLRo0eD9tm0aZNdd911ljdvXitfvrxb+RgAACC5CEoBAABkYH/++ac1bNjQcuXKZfPnz7dvv/3WRo0aZeedd15gHwWPXnvtNZs4caJ99dVXbrVirUJ84sSJwD4KSG3dutUWLVrkVjZevny5denSJahgabNmzaxixYq2bt06e+mll2zo0KH2xhtvRPw9AwCAzCFntBsAAACA5HvxxRdd1tKUKVMC91WqVCkoS+rVV1+1QYMG2e233+7ue+edd6xUqVL24YcfWrt27ey7776zBQsW2Nq1a61u3bpun9dff91uueUWe/nll61s2bI2bdo0O3XqlE2ePNly585t1atXt40bN9orr7wSFLwCAABILDKlAAAAMrA5c+a4QNKdd95pJUuWtCuvvNLefPPNwOM7d+60/fv3uyl7Hi3RXL9+fVu1apW7rZ+asucFpET7Z8+e3WVWefs0atTIBaQ8yrbavn27y9YCAABIKoJSAAAAGdiPP/5oEyZMsEsuucQWLlxo3bp1s0cffdSmTp3qHldASpQZ5afb3mP6qYCWX86cOa1YsWJB+4Q7hv81Qp08edJN+/NvAAAAHqbvAQAAZGAxMTEuw+n55593t5UptWXLFlc/qmPHjlFt24gRI+yZZ56JahsAAED6RaYUAABABqYV9apVqxZ0X9WqVW3Xrl3u99KlS7ufBw4cCNpHt73H9PPgwYNBj585c8atyOffJ9wx/K8RauDAgXb48OHAtnv37hS+WwAAkJkQlAIAAMjAtPKe6jr5/e9//3Or5HlFzxU0WrJkSeBxTaNTragGDRq42/p56NAht6qeZ+nSpS4LS7WnvH20It/p06cD+2ilvssuuyxopT+/PHnyWOHChYM2AAAAD0EpAACADKxPnz62evVqN33v+++/t+nTp9sbb7xh3bt3d49ny5bNevfubc8++6wrir5582a7//773Yp6rVu3DmRW3Xzzzfbwww/bmjVr7Msvv7QePXq4lfm0n9x7772uyHnnzp1t69atNnPmTBszZoz17ds3qu8fAABkXNSUAgAAyMDq1atnH3zwgZsqN2zYMJcZ9eqrr1r79u0D+/Tv39+OHTtmXbp0cRlR1157rS1YsMDy5s0b2GfatGkuEHXjjTe6Vffatm1rr732WtCKfZ9++qkLdtWpU8dKlChhgwcPdscEAABIDoJSAAAAGdytt97qtrgoW0oBK21x0Up7yrKKzxVXXGFffPFFitoKAADgYfoeAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAJAOxMbEWHqTHtsEAMg8cka7AQAAAADMsmXPbr/NHmOnD+6x9CBXyQusxJ29ot0MAEAmRlAKAAAASCcUkDq1b2e0mwEAQEQwfQ8AAAAAAAARR1AKAAAggxs6dKhly5YtaKtSpUrg8RMnTlj37t2tePHiVrBgQWvbtq0dOHAg6Bi7du2yli1bWv78+a1kyZLWr18/O3PmTNA+y5Yts9q1a1uePHmscuXK9vbbb0fsPQIAgMyHoBQAAEAmUL16ddu3b19gW7FiReCxPn362Mcff2yzZ8+2zz//3Pbu3Wtt2rQJPH727FkXkDp16pStXLnSpk6d6gJOgwcPDuyzc+dOt0+TJk1s48aN1rt3b3vooYds4cKFEX+vAAAgc6CmFAAAQCaQM2dOK1269Dn3Hz582CZNmmTTp0+3G264wd03ZcoUq1q1qq1evdquvvpq+/TTT+3bb7+1xYsXW6lSpaxWrVo2fPhwGzBggMvCyp07t02cONEqVapko0aNcsfQ8xX4Gj16tDVv3jzi7xcAAGR8ZEoBAABkAjt27LCyZcvaRRddZO3bt3fT8WTdunV2+vRpa9q0aWBfTe2rUKGCrVq1yt3Wzxo1ariAlEeBpiNHjtjWrVsD+/iP4e3jHSOckydPumP4NwAAAA9BKQAAgAyufv36brrdggULbMKECW6q3XXXXWd//fWX7d+/32U6FS1aNOg5CkDpMdFPf0DKe9x7LL59FGg6fvx42HaNGDHCihQpEtjKly+fqu8bAABkbEzfAwAAyOBatGgR+P2KK65wQaqKFSvarFmzLF++fFFr18CBA61v376B2wpgEZgCAAAeMqUAAAAyGWVFXXrppfb999+7OlMqYH7o0KGgfbT6nleDSj9DV+Pzbie0T+HCheMMfGmVPj3u3wAAADwEpQAAADKZo0eP2g8//GBlypSxOnXqWK5cuWzJkiWBx7dv3+5qTjVo0MDd1s/NmzfbwYMHA/ssWrTIBZGqVasW2Md/DG8f7xgAAABJRVAKAAAgg3v88cft888/t59++slWrlxp//jHPyxHjhx2zz33uFpOnTt3dtPoPvvsM1f4/MEHH3TBJK28J82aNXPBpw4dOtg333xjCxcutEGDBln37t1dtpN07drVfvzxR+vfv79t27bNxo8f76YH9unTJ8rvHgAAZFRRDUotX77cWrVq5VaKyZYtm3344YdBjz/wwAPufv928803B+3zxx9/uBVmNJKnVHV1ujQ66Ldp0yZX7DNv3ryujsHIkSPPacvs2bPdSjTaR6vPfPLJJ2n0rgEAAFLXL7/84gJQl112md11111WvHhxW716tZ1//vnu8dGjR9utt95qbdu2tUaNGrmpeO+//37g+QpgzZ071/1UsOq+++6z+++/34YNGxbYp1KlSjZv3jyXHVWzZk0bNWqUvfXWW24FPgAAgAxX6PzYsWOuU9OpUydr06ZN2H0UhJoyZUrgtjda51FAat++fa6DpOWONfLXpUsXmz59eqCgpkb/tITxxIkTXWq6Xk8BLO0nGlFUR04rxKjDpue2bt3a1q9fb5dffnmangMAAICUmjFjRryPa9Bt3LhxbouLCqMnNCjXuHFj27BhQ7LbCQAAkG6CUlopxr9aTDgKQnkFNkN99913bunjtWvXWt26dd19r7/+ut1yyy328ssvuwysadOmueKekydPdsshV69e3TZu3GivvPJKICg1ZswYF/zq16+fuz18+HAX5Bo7dqwLZAEAAAAAACCL1ZRatmyZlSxZ0qWjd+vWzX7//ffAY6tWrXIZT15ASpQRlT17dvvqq68C+yhNXQEpj9LMVeDzzz//DOyj5/lpH90PAAAAAACAdBCUUmbSihUrAreVBl6rVi279957A0Ge1KLspXfeecet9PLiiy+6Ap7KrDp79qx7fP/+/S5g5ZczZ04rVqyYe8zbp1SpUkH7eLcT2sd7PJyTJ0+6qYH+DQAAAAAAAGkUlNIUNy8Ao/pMjz32mJsut3PnTreqS2pq166d3Xbbba7wuGo8qQCnpuopeyraVH9Kq9l4mwqoAwAAAAAAII2CUgo+aclg+e9//+sKgz///PMuY2r+/PmWli666CIrUaKEff/99+62ak0dPHgwaJ8zZ864Ffm8OlT6eeDAgaB9vNsJ7RNXLSsZOHCgHT58OLDt3r07ld4lAADICtR30Kp5njVr1ljv3r3tjTfeiGq7AAAA0m1QSrWZ/v77b/f74sWL3cp2oilzaT2FTR031ZQqU6aMu60liw8dOmTr1q0L7LN06VKLiYmx+vXrB/ZZvny5W5nPoyLmqlF13nnnBfbRFEE/7aP74yvAXrhw4aANAAAgsVT64LPPPnO/q2TATTfd5AJTTz31lA0bNizazQMAAEh/Qalrr73WTdPTCnXqOLVs2dLd/7///c/KlSuXpGMdPXrUrYSnzcvC0u+7du1yj2mq4OrVq+2nn35yQaPbb7/dKleu7IqQS9WqVV3dqYcffti15csvv7QePXq4aX9aec/r8CmQ1rlzZ9u6davNnDnTrbbnn2rYq1cvVytr1KhRtm3bNhs6dKh9/fXX7lgAAABpYcuWLXbVVVe532fNmmWXX365rVy50q0c/Pbbb0e7eQAAAOkvKDV27FhXTPw///mPTZgwwS644AJ3v6buKUCUFAr8XHnllW4TBYr0++DBgy1Hjhy2adMmV1Pq0ksvdUGlOnXq2BdffOGylDzquFWpUsVuvPFGV9tKQTN/2rvqPX366acu4KXnqwaWjt+lS5fAPtdcc41Nnz7dPa9mzZruvX344YeucwgAAJAWlMXt9WmUfa4+j6hfs2/fvii3DgAAIO3lTOoTKlSo4AqOhxo9enSSX7xx48YWGxsb5+MLFy5M8BiaNqiAUnyuuOIKF8yKz5133uk2AACASKhevbpNnDjRZZ2rbICy0GXv3r1WvHjxaDcPAAAg/QWlVNRbHSdNqcuWLZtVqlTJmjZtSk0lAACAJHjxxRftH//4h7300kvWsWNHl60tc+bMCUzrAwAAyMySFJR67733XJ2l0ILmmiKnkb677747tdsHAACQKSlj/LfffnP9Km/xFVGJgfz580e1bQAAAOmqptT69evtwQcftNatW9uGDRvs+PHjbhU+1YVq1aqVdejQwb755pu0bS0AAEAmohqa/oCUXHjhhVayZMmotQkAACDdZUq9/vrrLiAVuhpM7dq17Z133nEBKq1qN3ny5LRoJwAAQKaixV1UCiGU7subN69bcfiBBx6wJk2aRKV9AAAA6SZT6ssvv7RHHnkkzse7du1qK1asSK12AQAAZGpatfjHH3+0AgUKuMCTtoIFC9oPP/xg9erVcyvwqW7nRx99FO2mAgAARDdTSivBXHrppXE+rsf27NmTWu0CAADI1FRP6rHHHrOnn3466P5nn33Wfv75Z/v0009tyJAhblW+22+/PWrtBAAAiHqmlKbnKZU8Lnny5LETJ06kVrsAAAAytVmzZtk999xzzv3t2rVzj4ke3759exRaBwAAkM5W31u4cKFbaS+cQ4cOpVabAAAAMj0N9q1cudLVjvLTfd5AYExMTLyDggAAAFkmKNWxY8d4Hw9XrBMAAADn6tmzp6vJuW7dOldDStauXWtvvfWWPfnkk4EBwVq1akW5pQAAAFEOSmmkDgAAAKlj0KBBVqlSJRs7dqy9++677r7LLrvM3nzzTbv33nvdbQWtunXrFuWWAgAApINMKQAAAKSe9u3buy0u+fLli2h7AAAA0mVQas6cOYna77bbbktJewAAALKUU6dO2cGDB8/JSq9QoULU2gQAAJCuglKtW7dOcB/VlDp79mxK2wQAAJDp7dixwzp16uQKm/vFxsbSpwIAAFkCNaUAAACi4IEHHrCcOXPa3LlzrUyZMiwYAwAAshxqSgEAAETBxo0b3cp7VapUiXZTAAAAoiJ7Sp5cuHBh+/HHH1OvNQAAAFlEtWrV7Lfffot2MwAAADJmUEo1DwAAAJB0L774ovXv39+WLVtmv//+ux05ciRoAwAAyOyYvgcAABAFTZs2dT9vvPHGoPspdA4AALKKFAWl7rvvPjeFDwAAAEnz2WefRbsJQKqJjYmxbNlTNAkjS7ULAJDMoNQ777xjd999t+XJk8cmTJgQuP/UqVM2Y8YMu//++5N6SAAAgCzn+uuvT5PjvvDCCzZw4EDr1auXvfrqq+6+EydO2GOPPeb6aidPnrTmzZvb+PHjrVSpUoHn7dq1y7p16+aCZQULFrSOHTvaiBEj3AqBHk017Nu3r23dutXKly9vgwYNcqsIAgr8/DZ7jJ0+uMfSi1wlL7ASd/aKdjMAAKkZlHrwwQft5ptvtpIlSwbd/9dff7nHCEoBAACEt2nTJrv88sste/bs7vf4XHHFFUk+/tq1a+1f//rXOc/t06ePzZs3z2bPnm1FihSxHj16WJs2bezLL790j2uqYMuWLa106dK2cuVK27dvn+vT5cqVy55//nm3z86dO90+Xbt2tWnTptmSJUvsoYcesjJlyrggF6CA1Kl9O6PdDABAZg5KeXUOQv3yyy+ukwMAAIDwatWqZfv373eDe/pdfapwC8ckp6bU0aNHrX379vbmm2/as88+G7j/8OHDNmnSJJs+fbrdcMMN7r4pU6ZY1apVbfXq1Xb11Vfbp59+at9++60tXrzYZU+pbcOHD7cBAwbY0KFDLXfu3DZx4kSrVKmSjRo1yh1Dz1+xYoWNHj2aoBQAAEjboNSVV17pOkjaVJDTn8qtTpNGz5RBBQAAgPDUXzr//PMDv6em7t27u0wmFVD3B6XWrVtnp0+fDhRWlypVqliFChVs1apVLiilnzVq1AiazqdAk6bzaaqe+oHax38Mb5/evXun6vsAAABZR6KDUq1bt3Y/N27c6DogqjXg0ejZhRdeaG3btk2bVgIAAGQCFStWDPt7SqlW1Pr16930vVDKzFJfrWjRokH3KwClx7x9/AEp73Hvsfj2OXLkiB0/ftzy5ct3zmurfpU2j/YFAABIclBqyJAh7qeCTyp0njdv3sQ+FQAAAGY2Z86cRO972223JWq/3bt3u6LmixYtSnf9MxVKf+aZZ6LdDAAAkFlqSmklFm+1vYMHD1pMTEzQ40oFBwAAQNyZ557QmlL+up2JrSml6Xnqk9WuXTvoucuXL7exY8fawoULXb/t0KFDQdlSBw4ccIXNRT/XrFkTdFw97j3m/fTu8+9TuHDhsFlSolUAtVqfP1NKq/YBAABI9qSehh07dth1113nOh9KO1fBS23KoNJPAAAAhKfBPG9TcXEVFJ8/f74LGGn75JNPXHBpwYIFiT6man1u3rzZlVjwtrp167qi597vWkVPq+V5tm/fbrt27bIGDRq42/qpYyi45VHmlQJO1apVC+zjP4a3j3eMcPLkyeOO4d8AAACSnSn1wAMPuCLnc+fOdUsAh1uJDwAAAPFTgXCtaHfttdcG7lPdzvz581uXLl3su+++S9RxChUqZJdffnnQfQUKFLDixYsH7u/cubPLWCpWrJgLDPXs2dMFk1TkXJo1a+aCTx06dLCRI0e6+lGDBg1yxdMVWJKuXbu6zKv+/ftbp06dbOnSpTZr1iybN29eKp4VAACQlSQ5KKURN6WJa9UWAAAAJM8PP/xwTvFxKVKkiP3000+p+lqjR4+27Nmzu0VpVHhcwa/x48cHHs+RI4cbcNRqewpWKailkg3Dhg0L7KOMeAWg+vTpY2PGjLFy5crZW2+95Y4FAAAQkaCURtF+++23ZL0YAAAA/q969eq57KV33303sKqdajT169fPrrrqqhQde9myZUG3VQB93LhxbouLyjJo+mB8GjdubBs2bEhR2wAAAJJdU+rFF190advq7Pz++++uYKV/AwAAQMImTZpk+/btc4vEVK5c2W36fc+ePe4xAACAzC7JmVJNmzYNFNX008oxqi+V2JViAAAAsrJLLrnENm3a5IqFb9u2zd1XtWpV19eiZicAAMgKkhyU+uyzz9KmJQAAAFnE6dOn3UrGqtWpIuPaAAAAspokB6Wuv/76tGkJAABAFpErVy43VY8McwAAkJUluaaUfPHFF3bffffZNddc4+oeiIp0rlixIrXbBwAAkCk99dRT9uSTT9off/wR7aYAAABkjKDUf//7X7f0r1LO169f75YVlsOHD9vzzz+fFm0EAADIdMaOHWvLly+3smXL2mWXXWa1a9cO2gAAADK7JE/fe/bZZ23ixIl2//3324wZMwL3N2zY0D0GAACAhLVu3TraTQAAAMhYQant27dbo0aNzrm/SJEidujQodRqFwAAQKY2ZMiQaDcBAAAgYwWlSpcubd9//71deOGFQferntRFF12Umm0DAADI9NatW2ffffed+7169ep25ZVXRrtJAAAA6TMo9fDDD1uvXr1s8uTJli1bNtu7d6+tWrXKHn/8cXv66afTppUAAACZzMGDB61du3a2bNkyK1q0qLtPWedNmjRxJRLOP//8aDcRAAAgfRU6f+KJJ+zee++1G2+80Y4ePeqm8j300EP2yCOPWM+ePdOmlQAAAJmM+k1//fWXbd261a3Ap23Lli125MgRe/TRR6PdPAAAgPSXKaXsKC1h3K9fPzeNT4GpatWqWcGCBdOmhQAAAJnQggULbPHixVa1atXAfepTjRs3zpo1axbVtgEAAKTLoJQnd+7cruMEAACApIuJibFcuXKdc7/u02MAAACZXaKCUm3atLG3337bChcu7H6Pz/vvv59abQMAAMi0brjhBlen89///reVLVvW3bdnzx7r06ePK5MAAACQ2SUqKFWkSBE3bU8UmPJ+BwAAQPKMHTvWbrvtNreicfny5d19u3fvtssvv9zee++9aDcPAAAgfQSlpkyZEvhdGVMAAABIGQWi1q9f7+pKbdu2zd2n+lJNmzaNdtMAAADSZ00ppZprip63dLFHK8W0bt3ali5dmprtAwAAyLSUfX7TTTe5DQAAIKvJntQnLFu2zE6dOnXO/SdOnLAvvvgitdoFAACQqT366KP22muvhZ3W17t376i0CQAAIF1mSm3atCnw+7fffmv79+8P3D579qxb1viCCy5I/RYCAABkQv/9739tzpw559x/zTXX2AsvvGCvvvpqVNoFAACQ7oJStWrVcinm2jSFL1S+fPns9ddfT+32AQAAZEq///67W0wmlBaV+e2336LSJgAAgHQZlNq5c6fFxsbaRRddZGvWrLHzzz8/8Fju3LmtZMmSliNHjrRqJwAAQKZSuXJll2neo0ePoPvnz5/v+lsAAACZXaKDUhUrVnQ/Y2Ji0rI9AAAAWULfvn1dQOrXX38NZKEvWbLERo0axdQ9AACQJSS50Lm/rpRG91QLwb8lxfLly61Vq1ZWtmxZNy3www8/DHpcmVmDBw+2MmXKuOmBWiJ5x44dQfv88ccf1r59e5fqrhUBO3fubEePHj2nHtZ1111nefPmdcsvjxw58py2zJ4926pUqeL2qVGjhn3yySdJei8AAABJ0alTJxeAmjRpkjVp0sRt7733nk2YMMEefvjhaDcPAAAg/WRKeX788Uf7xz/+YZs3b3aBJAWORL97Rc8T69ixY1azZk3XKWvTps05jyt4pFVppk6dapUqVbKnn37amjdv7gJiCh6JAlL79u2zRYsW2enTp+3BBx+0Ll262PTp093jR44csWbNmrmA1sSJE1279XoKYGk/Wblypd1zzz02YsQIu/XWW91zW7dubevXr7fLL788qacIAAAgUbp16+Y2ZUtpAK5gwYLRbhIAAED6zZTq1auXCxAdPHjQ8ufPb1u3bnUZT3Xr1rVly5Yl6VgtWrSwZ5991gW5QinYpdT1QYMG2e23325XXHGFvfPOO7Z3795ARtV3333nsrXeeustq1+/vl177bWu2PqMGTPcfjJt2jQ7deqUTZ482apXr27t2rVzSzC/8sorgdcaM2aM3XzzzdavXz+rWrWqDR8+3GrXru2WZAYAAEgrZ86cscWLF9v7778fGOhTHyY06xsAACAzSnJQatWqVTZs2DArUaKEZc+e3W0KBinLSMGe1KLC6vv373cZTh6tUKPgk9rgtUUZTwqIebS/2vTVV18F9mnUqJErxu5RttX27dvtzz//DOzjfx1vH+91AAAAUtvPP//sSgZo8K179+4uW0pefPFFe/zxx6PdPAAAgPQXlNL0vEKFCrnfFZjyMpJUCF2BntSigJSUKlUq6H7d9h7TT63655czZ04rVqxY0D7hjuF/jbj28R4P5+TJk25qoH8DAABISva5BtY0SKapex5lkKvgOQAAQGaX5JpSqrH0zTffuCl8ylpS3SdlIb3xxhtZavliZYY988wz0W4GAADIoL744gtX19KfzS0XXnih7dmzJ2rtAgAASLeZUqrxFBMT437XND5Ns9PKdlqtTkXJU0vp0qXdzwMHDgTdr9veY/qp2lahtRm0Ip9/n3DH8L9GXPt4j4czcOBAO3z4cGDbvXt3Ct4tAADIatSfCrdAzC+//BLISgcAAMjMkhyUUq0lb6W8ypUr27Zt2+y3335zwaEbbrgh1RqmTCwFhfzp65oip1pRDRo0cLf189ChQ7Zu3brAPkuXLnWdPGVxefuoELtW5vNopb7LLrvMzjvvvMA+oWny2sd7nXDy5MljhQsXDtoAAAASS6sDa1EXj1YyVoHzIUOG2C233JKkY02YMMEtCuP1SdSHmT9/fuDxEydOuLpVxYsXdyv8tW3b9pwBuV27dlnLli3dQjYqj6AFYDTY56dFbbQYjPpB6ge+/fbbyX7/AAAASQ5K+Sk7SJtqOKkjlVTqeG3cuNFtoqwr/a5OkY7Xu3dvtzrfnDlzbPPmzXb//fdb2bJlrXXr1m5/rZSnVfMefvhhW7NmjX355ZfWo0cPt8Ke9pN7773XpcV37tzZrRQ4c+ZMt9pe3759g2o6aBW/UaNGuSDb0KFD7euvv3bHAgAASAsvv/yy67tUq1bNBY3UZ/Gm7qnYeVKUK1fOXnjhBTdQpz6MBgpVQF19H+nTp499/PHHNnv2bPv8889dTVBvkFGUsaWAlFYs1pTCqVOnuoDT4MGDA/uon6Z9mjRp4vpr6qc99NBDtnDhwlQ8KwAAICtJck0pjZiplpKm6nnLFWvErWfPnm5kL1euXIk+ljpN6th4vEBRx44dXUeof//+duzYMevSpYvLiNIqfwoe5c2bN/CcadOmueDRjTfe6Fbd08iffxqhVuz79NNP3ehgnTp1XHF2dbB0TM8111xj06dPd1MTn3zySbvkkkvsww8/dPWzAAAA0kL58uVdnU4NmOmn+lUaRGvfvn1Q4fPEaNWqVdDt5557zmVPrV692gWsJk2a5Po6Xlb7lClT3OCeHr/66qtdX+nbb7+1xYsXu8VeatWqZcOHD7cBAwa4wToN8E2cONFlsmsQT/T8FStW2OjRo10mPQAAQJoHpRR8ev/9912Bc29626pVq1yH5ffff3cdoMRq3LixxcbGxvm4sqVUt0pbXJSlpU5WfJTOrmKi8bnzzjvdBgAAkNZUVqBKlSo2d+5cF4TSllqU9aSMKA3sqa+m7Cm9XtOmTQP76LUrVKjg+nAKSulnjRo1glYjVqCpW7duLtvqyiuvdPv4j+Hto4wpAACAiASlFACaMWOGtWjRIijoo9G+e+65J0lBKQAAgKxImeWaspeaVOpAQSgdV1nsH3zwgZsaqKl2ynQqWrRo0P4KQO3fv9/9rp/+gJT3uPdYfPuo5ufx48fDZnedPHnSbR7tCwAAkOyaUipsqXoHoZTOHbqkMQAAAMJTaQHVjgotJp5cWsRFASgtCqMMJ5VD0JS8aBoxYoQrpeBtGsQEAABIdqaU6jepxoBqEShAJRoBU+0CCoMDAAAkztq1a93qv6rnpKlzBQoUCHpc5RKSQoODWhFPVEdTx9fiLnfffbcrYK76nP5sKa2+p5WORT+1aIyftzqff5/QFft0W6v9xVUDa+DAgUGLyyhTisAUAABIdlBqw4YNrgOlopk1a9Z096k4pzo7KjbuX8klqZ0pAACArEIBIi3QklZiYmLcwKECVJouqP6b93rbt293qx179UH1UwOMBw8etJIlS7r7Fi1a5AJOmgLo7fPJJ58EvYb28Y4RjgYwvUFMIL2KjYmxbNlTtCh5lmoXAEQ1KBWuA8WIFwAAQNIo6zy1KCNJ9T5VvPyvv/5yNUCXLVtmCxcudNPmtKqfMpa0QIwCTVq4RsEkFTmXZs2aueBThw4d3GI2qh+lVYk1xdALKnXt2tXGjh3rVkfu1KmTLV261GbNmmXz5s1LtfcBRIMCP7/NHmOnD+6x9CJXyQusxJ29ot0MAEh/QanU7EABAAAg5ZThdP/999u+fftcEEqL0CggddNNN7nHR48ebdmzZ3cDi8qe0qp548ePDzw/R44cbiVA1aJSsEpTCVWTyr8CsuqHKgDVp08fNy1QWfNvvfWWOxaQ0SkgdWrfzmg3AwCynCQHpQAAAJC+TJo0Kd7H8+bNa+PGjXNbXCpWrHjO9LxQjRs3dqUcAAAAUgOTlAEAAAAAABBxBKUAAAAAAAAQcQSlAAAAAAAAEHEEpQAAAKKkR48e9scff0S7GQAAABknKEUHCgAAIHl++eWXwO/Tp0+3o0ePut9r1Khhu3fvjmLLAAAA0mlQig4UAABAylWpUsWtdHfvvffaiRMnAv2on376yU6fPh3t5gEAAKS/oBQdKAAAgJQ7dOiQzZ492+rUqWMxMTF2yy232KWXXmonT560hQsX2oEDB6LdRAAAgPQVlKIDBQAAkHIazLvqqqvsscces3z58tmGDRtsypQpliNHDps8ebJVqlTJLrvssmg3EwAAIP0EpehAAQAApFzRokWtfv361rdvXzt16pQdP37cGjZsaDlz5rSZM2fan3/+aZMmTYp2MwEAANJczqR0oGrVquU6TeE6UBdccIGtXbs2bVsLAACQwe3Zs8dWrVplK1eutDNnzrgs9Hr16rn+1fr1661cuXJ27bXXRruZAAAA6SdTSh2oQYMGWZ48eQIdqOuuuy7QgcqWLRsdKAAAgASUKFHCWrVqZSNGjLD8+fO7Qb2ePXu6vtTjjz9uRYoUseuvvz7azQQAAEg/QSk6UAAAAKlPfai77rrLcuXKZUuXLrWdO3faP//5z2g3CwAAIP0EpULRgQIAAEiZTZs2uel6olWO1a8qXbq03X333dFuGgAAQPqpKRXagVINKaEDBQAAkDzly5cP/L5ly5aotgUAACBDBKXoQAEAAAAAACAq0/cAAAAAAACA5CIoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAJDBjRgxwurVq2eFChWykiVLWuvWrW379u1B+5w4ccK6d+9uxYsXt4IFC1rbtm3twIEDQfvs2rXLWrZsafnz53fH6devn505cyZon2XLllnt2rUtT548VrlyZXv77bcj8h4BAEDmQ1AKAAAgg/v8889dwGn16tW2aNEiO336tDVr1syOHTsW2KdPnz728ccf2+zZs93+e/futTZt2gQeP3v2rAtInTp1ylauXGlTp051AafBgwcH9tm5c6fbp0mTJrZx40br3bu3PfTQQ7Zw4cKIv2cAAJDx5Yx2AwAAAJAyCxYsCLqtYJIyndatW2eNGjWyw4cP26RJk2z69Ol2ww03uH2mTJliVatWdYGsq6++2j799FP79ttvbfHixVaqVCmrVauWDR8+3AYMGGBDhw613Llz28SJE61SpUo2atQodww9f8WKFTZ69Ghr3rx5VN47AADIuMiUAgAAyGQUhJJixYq5nwpOKXuqadOmgX2qVKliFSpUsFWrVrnb+lmjRg0XkPIo0HTkyBHbunVrYB//Mbx9vGOEOnnypHu+fwMAAPAQlAIAAMhEYmJi3LS6hg0b2uWXX+7u279/v8t0Klq0aNC+CkDpMW8ff0DKe9x7LL59FGw6fvx42FpXRYoUCWzly5dP5XcLAAAyMoJSAAAAmYhqS23ZssVmzJgR7abYwIEDXdaWt+3evTvaTQIAAOkINaUAAAAyiR49etjcuXNt+fLlVq5cucD9pUuXdgXMDx06FJQtpdX39Ji3z5o1a4KO563O598ndMU+3S5cuLDly5fvnPZohT5tAAAA4ZApBQAAkMHFxsa6gNQHH3xgS5cudcXI/erUqWO5cuWyJUuWBO7bvn277dq1yxo0aOBu6+fmzZvt4MGDgX20kp8CTtWqVQvs4z+Gt493DAAAgKQgUwoAACATTNnTynofffSRFSpUKFADSnWclMGkn507d7a+ffu64ucKNPXs2dMFk7TynjRr1swFnzp06GAjR450xxg0aJA7tpft1LVrVxs7dqz179/fOnXq5AJgs2bNsnnz5kX1/QMAgIyJTCkAAIAMbsKECa5mU+PGja1MmTKBbebMmYF9Ro8ebbfeequ1bdvWGjVq5Kbivf/++4HHc+TI4ab+6aeCVffdd5/df//9NmzYsMA+ysBSAErZUTVr1rRRo0bZW2+95VbgAwAASCoypQAAADLB9L2E5M2b18aNG+e2uFSsWNE++eSTeI+jwNeGDRuS1U4AAAA/MqUAAAAAAAAQcQSlAAAAAAAAEHEEpQAAAAAAABBxBKUAAAAAAAAQcQSlAAAAAAAAEHHpOig1dOhQy5YtW9BWpUqVwOMnTpyw7t27W/Hixa1gwYJuieMDBw4EHWPXrl3WsmVLy58/v5UsWdL69etnZ86cCdpn2bJlVrt2bcuTJ49VrlzZ3n777Yi9RwAAAAAAgKwoXQelpHr16rZv377AtmLFisBjffr0sY8//thmz55tn3/+ue3du9fatGkTePzs2bMuIHXq1ClbuXKlTZ061QWcBg8eHNhn586dbp8mTZrYxo0brXfv3vbQQw/ZwoULI/5eAQAAAAAAsoqcls7lzJnTSpcufc79hw8ftkmTJtn06dPthhtucPdNmTLFqlataqtXr7arr77aPv30U/v2229t8eLFVqpUKatVq5YNHz7cBgwY4LKwcufObRMnTrRKlSrZqFGj3DH0fAW+Ro8ebc2bN4/4+wUAAAAAAMgK0n2m1I4dO6xs2bJ20UUXWfv27d10PFm3bp2dPn3amjZtGthXU/sqVKhgq1atcrf1s0aNGi4g5VGg6ciRI7Z169bAPv5jePt4xwAAAAAAAEAWy5SqX7++m2532WWXual7zzzzjF133XW2ZcsW279/v8t0Klq0aNBzFIDSY6Kf/oCU97j3WHz7KHB1/Phxy5cvX9i2nTx50m0e7Q8AAAAAAIBMEJRq0aJF4PcrrrjCBakqVqxos2bNijNYFCkjRoxwQTIAAAAAAABkwul7fsqKuvTSS+377793daZUwPzQoUNB+2j1Pa8GlX6Grsbn3U5on8KFC8cb+Bo4cKCra+Vtu3fvTrX3CQAAAAAAkNllqKDU0aNH7YcffrAyZcpYnTp1LFeuXLZkyZLA49u3b3c1pxo0aOBu6+fmzZvt4MGDgX0WLVrkAk7VqlUL7OM/hrePd4y45MmTxx3HvwEAAABApMTGxFh6lF7bBSD9SdfT9x5//HFr1aqVm7K3d+9eGzJkiOXIkcPuueceK1KkiHXu3Nn69u1rxYoVc0Ghnj17umCSVt6TZs2aueBThw4dbOTIka5+1KBBg6x79+4uqCRdu3a1sWPHWv/+/a1Tp062dOlSNz1w3rx5UX73AAAAABC3bNmz22+zx9jpg3ssvchV8gIrcWevaDcDQAaRroNSv/zyiwtA/f7773b++efbtddea6tXr3a/y+jRoy179uzWtm1bV3Rcq+aNHz8+8HwFsObOnWvdunVzwaoCBQpYx44dbdiwYYF9KlWq5AJQffr0sTFjxli5cuXsrbfecscCAAAAgPRMAalT+3ZGuxkAkPmCUjNmzIj38bx589q4cePcFhdlWX3yySfxHqdx48a2YcOGZLcTAAAAAAAAmbimFAAAAAAAADIHglIAAAAAAACIOIJSAAAAAAAAiDiCUgAAAAAAAIg4glIAAAAAAACIOIJSAAAAAAAAiDiCUgAAAAAAAIg4glIAAAAAAACIOIJSAAAAAAAAiDiCUgAAAAAAAIg4glIAAAAAAACIOIJSAAAAAAAAiDiCUgAAAAAAAIg4glIAAAAZ3PLly61Vq1ZWtmxZy5Ytm3344YdBj8fGxtrgwYOtTJkyli9fPmvatKnt2LEjaJ8//vjD2rdvb4ULF7aiRYta586d7ejRo0H7bNq0ya677jrLmzevlS9f3kaOHBmR9wcAADInglIAAAAZ3LFjx6xmzZo2bty4sI8rePTaa6/ZxIkT7auvvrICBQpY8+bN7cSJE4F9FJDaunWrLVq0yObOnesCXV26dAk8fuTIEWvWrJlVrFjR1q1bZy+99JINHTrU3njjjYi8RwAAkPnkjHYDAAAAkDItWrRwWzjKknr11Vdt0KBBdvvtt7v73nnnHStVqpTLqGrXrp199913tmDBAlu7dq3VrVvX7fP666/bLbfcYi+//LLLwJo2bZqdOnXKJk+ebLlz57bq1avbxo0b7ZVXXgkKXgEAACQWmVIAAACZ2M6dO23//v1uyp6nSJEiVr9+fVu1apW7rZ+asucFpET7Z8+e3WVWefs0atTIBaQ8yrbavn27/fnnn2Ff++TJky7Dyr8BAAB4CEoBAABkYgpIiTKj/HTbe0w/S5YsGfR4zpw5rVixYkH7hDuG/zVCjRgxwgXAvE11qAAAADwEpQAAAJAmBg4caIcPHw5su3fvjnaTAABAOkJQCgAAIBMrXbq0+3ngwIGg+3Xbe0w/Dx48GPT4mTNn3Ip8/n3CHcP/GqHy5MnjVvPzbwAAAB6CUgAAAJlYpUqVXNBoyZIlgftU20m1oho0aOBu6+ehQ4fcqnqepUuXWkxMjKs95e2jFflOnz4d2Ecr9V122WV23nnnRfQ9AQCAzIGgFAAAQAZ39OhRtxKeNq+4uX7ftWuXZcuWzXr37m3PPvuszZkzxzZv3mz333+/W1GvdevWbv+qVavazTffbA8//LCtWbPGvvzyS+vRo4dbmU/7yb333uuKnHfu3Nm2bt1qM2fOtDFjxljfvn2j+t4BAEDGlTPaDQAAAEDKfP3119akSZPAbS9Q1LFjR3v77betf//+duzYMevSpYvLiLr22mttwYIFljdv3sBzpk2b5gJRN954o1t1r23btvbaa68FHleh8k8//dS6d+9uderUsRIlStjgwYPdMQEAAJKDoBQAAEAG17hxY4uNjY3zcWVLDRs2zG1x0Up706dPj/d1rrjiCvviiy9S1FYAAAAP0/cAAAAAAAAQcQSlAAAAAAAAEHEEpQAAAAAAABBxBKUAAAAAAAAQcQSlAAAAAAAAEHEEpQAAAAAAERUbE2PpUXptF5BZ5Yx2AwAAAAAAWUu27Nntt9lj7PTBPZZe5Cp5gZW4s1e0mwFkKQSlAAAAAAARp4DUqX07o90MAFHE9D0AAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAAEQcQSkAAAAAAABEHEEpAAAAAAAARBxBKQAAAAAAkiA2JsbSm/TYJiAhORPcAwAAAAAABGTLnt1+mz3GTh/cY+lBrpIXWIk7e0W7GUCSEZQCAAAAACCJFJA6tW9ntJsBZGhM3wMAAAAAAEDEEZQCAAAAAABAxBGUAgAAAAAAQMQRlAoxbtw4u/DCCy1v3rxWv359W7NmTbSbBAAAkK7QXwIAAKmBoJTPzJkzrW/fvjZkyBBbv3691axZ05o3b24HDx6MdtMAAADSBfpLAJCxxcbEWHqTHtuEyGD1PZ9XXnnFHn74YXvwwQfd7YkTJ9q8efNs8uTJ9sQTT0S7eQAAAFFHfwkAMrZs2bPbb7PHuNUD04NcJS+wEnf2inYzECUEpf6fU6dO2bp162zgwIGB+7Jnz25Nmza1VatWRbVtAAAA6QH9JQDIHBSQOrVvZ7SbARCU8vz222929uxZK1WqVND9ur1t27Zz9j958qTbPIcPH3Y/jxw5kmZtPD/PSTtV4FSaHR8AgMzi/Dxpd032jhsbG2tZTUboL50oWNxOF/3/rxltMQWLJ+n9pqf2Z+S2J7X9tD31ZJW2p7f2Z5W2a5qfMr3Sm/TarmhKbH+JoFQyjRgxwp555plz7i9fvnxU2gMAAIINTuPj//XXX1akSJE0fpWMjf7S//NABp7WmJHbntHbT9ujg7ZHR0ZuO1LUXyIo9f+UKFHCcuTIYQcOHAi6X7dLly59zv5KW1eRT09MTIz98ccfVrx4ccuWLVtE2gwgfYwA6I+r3bt3W+HChaPdHAARoBE/dbDKli1rWQ39pfSP61L0cO6jg/MePZz76DiSQc57YvtLBKX+n9y5c1udOnVsyZIl1rp160DHSbd79Ohxzv558uRxm1/RokUj1l4A6YsuCOn5ogAgdWXVDCn6SxkH16Xo4dxHB+c9ejj30VE4A5z3xPSXCEr5aCSvY8eOVrduXbvqqqvs1VdftWPHjgVWlwEAAMjq6C8BAIDUQlDK5+6777Zff/3VBg8ebPv377datWrZggULzinmCQAAkFXRXwIAAKmFoFQIpZ6HSz8HgHA0LWXIkCHnTE8BgMyM/lL6xXUpejj30cF5jx7OfXTkyWTnPVtsVlzPGAAAAAAAAFGVPbovDwAAAAAAgKyIoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAkw/Lly61Vq1ZWtmxZy5Ytm3344YfRbhIAIAsbMWKE1atXzwoVKmQlS5a01q1b2/bt26PdrCznhRdecP2C3r17R7spWcKePXvsvvvus+LFi1u+fPmsRo0a9vXXX0e7WZna2bNn7emnn7ZKlSq5c37xxRfb8OHDjVLVkf97IzY21q2EW6ZMGfdZNG3a1Hbs2GEZDUEpAEiGY8eOWc2aNW3cuHHRbgoAAPb5559b9+7dbfXq1bZo0SI7ffq0NWvWzF2vEBlr1661f/3rX3bFFVdEuylZwp9//mkNGza0XLly2fz58+3bb7+1UaNG2XnnnRftpmVqL774ok2YMMHGjh1r3333nbs9cuRIe/3116PdtCz398bIkSPttddes4kTJ9pXX31lBQoUsObNm9uJEycsI2H1PQBIIY1cfPDBB25UGgCA9ODXX391GVMKVjVq1Cjazcn0jh49arVr17bx48fbs88+a7Vq1bJXX3012s3K1J544gn78ssv7Ysvvoh2U7KUW2+91UqVKmWTJk0K3Ne2bVuXqfPee+9FtW1Z6e+N2NhYl0H12GOP2eOPP+7uO3z4sPts3n77bWvXrp1lFGRKAQAAAJmM/jiRYsWKRbspWYKy1Fq2bOmmzyAy5syZY3Xr1rU777zTBWCvvPJKe/PNN6PdrEzvmmuusSVLltj//vc/d/ubb76xFStWWIsWLaLdtCxl586dtn///qD/c4oUKWL169e3VatWWUaSM9oNAAAAAJB6YmJiXE0jTW26/PLLo92cTG/GjBm2fv16N30PkfPjjz+6aWR9+/a1J5980p3/Rx991HLnzm0dO3aMdvMydYbakSNHrEqVKpYjRw5XY+q5556z9u3bR7tpWcr+/fvdT2VG+em291hGQVAKAAAAyGRZO1u2bHHZC0hbu3fvtl69erk6Xnnz5o12c7Jc8FWZUs8//7y7rUwpfe9VX4egVNqZNWuWTZs2zaZPn27Vq1e3jRs3uiC4ppJx3pEcTN8DAAAAMokePXrY3Llz7bPPPrNy5cpFuzmZ3rp16+zgwYOunlTOnDndpjpeKj6s35VFgrShFceqVasWdF/VqlVt165dUWtTVtCvXz+XLaWaRVrtsEOHDtanTx+3Aigip3Tp0u7ngQMHgu7Xbe+xjIKgFAAAAJDBqeitAlIqhLt06VK3XDvS3o033mibN2922SLepuwdTWXS75rehLSh6anbt28Puk91jipWrBi1NmUFf//9t2XPHhxG0PdcmWuInEqVKrngk+p7eTStUqvwNWjQwDISpu8BQDJX2fn++++Dig2q86mCshUqVIhq2wAAWXPKnqbTfPTRR1aoUKFATREVvtWqWEgbOtehdbu0LHvx4sWp55XGlJ2jotuavnfXXXfZmjVr7I033nAb0k6rVq1cDSn1dzV9b8OGDfbKK69Yp06dot20LPf3Ru/evd1qn5dccokLUj399NNuGmVGWxE8W6yGVQAASbJs2TJr0qTJOfdrLr2WYQUAINLLhYczZcoUe+CBByLenqyscePGVqtWLXv11Vej3ZRMT1NVBw4caDt27HB/lKvo+cMPPxztZmVqf/31lwt+KCtTU1cVBLnnnnts8ODBrsg8Ivf3RmxsrA0ZMsQFYg8dOmTXXnutjR8/3i699FLLSAhKAQAAAAAAIOKoKQUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQAAAAAAgIgjKAUAAAAAAICIIygFAAAAAACAiCMoBQBxyJYtm3344Yfu959++snd3rhxY7SbBQAAgHRi6NChVqtWrWg3A8iwCEoBSLFff/3VcufObceOHbPTp09bgQIFbNeuXZaZlC9f3vbt22eXX365ZdVOlm4rMKctZ86cVqJECWvUqJG9+uqrdvLkyai2FQCAjN43+vvvv23gwIF28cUXW968ee3888+366+/3j766KPAPo0bN3bX4RkzZgQ9V9fiCy+8MOi+48eP25AhQ+zSSy+1PHnyuOv2nXfeaVu3bg3az7u+33zzzee06aWXXnKP6XVD9w/dqlSpck47tem1L7jgAmvVqpW9//77iT6H//3vf91xihQpYgULFrQrrrjChg0bZn/88UfQ8cNt/vYCSN8ISgFIsVWrVlnNmjVdh2v9+vVWrFgxq1ChQpKOcerUqTRrX2q8bo4cOax06dIuGJPZJOXcV69e3QXn1LH+7LPPXOd2xIgRds0119hff/2Vpu0EACAz9426du3qgjavv/66bdu2zRYsWGB33HGH/f7770H7KWA1aNAgF+yKiwaLmjZtapMnT7Znn33W/ve//9knn3xiZ86csfr169vq1auD9i9Tpoy7rv/yyy9B9+v54drt9Qf824oVK4L2efjhh939P/zwgwswVatWzdq1a2ddunSxhDz11FN29913W7169Wz+/Pm2ZcsWGzVqlH3zzTf27rvvuvPkve6aNWvccxYvXhy4LynBLwDRRVAKQIqtXLnSGjZs6H5Xh8T7PT4PPPCAtW7d2p577jkrW7asXXbZZe7+3bt321133WVFixZ1Hbjbb7/dTZ0L7SCpM6SRN3WievToEXhMwRI9RyNqhQsXdsc6cODAOdk/b731llWqVMl17GTHjh0u60e31WlatGhR0GuGTt9btmyZu71kyRKrW7eu5c+f3wVmtm/fHvQ8dQRLlixphQoVsoceesieeOKJoOwjHeeqq65ynVa9Z527n3/+Oew589qg0VG9ltqqzK3PP/88aD913Fq0aOHOQalSpaxDhw7222+/BR7X6KHOWe/evd2oafPmzS2xFJRTcE6fWY0aNaxnz57u9fWaL774YqKPAwBAZpacvtGcOXPsySeftFtuucVlPdWpU8ddZzt16hS03z333GOHDh2yN998M85jKXNKgbG5c+e6vlDFihVdf0PBoapVq1rnzp0tNjY2sL/6Ks2aNbOpU6cGvQf1H1q2bBlnf8C/qU/hp76R7i9XrpxdffXVrp/wr3/9y7VbAaS4KMj0/PPPuyCUMrXU59H5uOmmm1z7O3bs6PqI3usqo0yKFy8euE+PxyUl/Uh54YUXXP9KfTudxxMnTpzzGupn6jyrr6YMsvHjxwcNBuo19dp6XJ+NBviArIqgFIBk0UVbQRRtr7zyiutk6Hd1plSHSb//85//jPcYCugoiKMAkDpNGvFTgEQX+S+++MK+/PJL1ylQOrmXzTNhwgTr3r27G2XbvHmz68BVrlzZPRYTE+M6EkrrVqBEx/3xxx/dSJvf999/7zo1GkVTkEnPa9OmjUuz/+qrr2zixIk2YMCARJ0HjeSp0/T111+7Dpq/4zht2jQXdFMnbN26dW6kUe33aLRSgTml5m/atMl1HvW+FHiKT79+/eyxxx6zDRs2WIMGDVw6vDeKqk7qDTfcYFdeeaVrk0ZZ1ZlSp8pPnU69X51jvd+UUGdLQTBGJQEAWVlK+0YKpiibKaHMYwVL1P/QVDZNDwxn+vTpLoijbC2/7NmzW58+fezbb791WUd+6sO8/fbbQcGb9u3bu/5CalFA6bzzzou3z6D+k/p/cZ0rncfkSmk/ctasWW6AU0Ez9bMUWPIHnLz2Dx482PUBv/vuO7fv008/HQj4vfbaa+51dSz1g7V/6NRLIEuJBYBkOH36dOzOnTtjv/nmm9hcuXK5n99//31swYIFYz///HP32K+//hrn8zt27BhbqlSp2JMnTwbue/fdd2Mvu+yy2JiYmMB9ejxfvnyxCxcudLfLli0b+9RTT4U95qeffhqbI0eO2F27dgXu27p1q4YBY9esWeNuDxkyxLX34MGDgX107Jw5c8bu2bMncN/8+fPd8z744AN3W+9Htzds2OBuf/bZZ+724sWLA8+ZN2+eu+/48ePudv369WO7d+8e1MaGDRvG1qxZ0/3++++/u/2XLVuW4Pn2t+GFF14I+hzKlSsX++KLL7rbw4cPj23WrFnQ83bv3u2et337dnf7+uuvj73yyisTfD2dK6+t4W77DRgwwH1OAABkVSntG2kfXdP13Lp168b27t07dsWKFUH76Breq1ev2BMnTsRWrFgxdtiwYe7+0aNHu9uevHnzuv3CWb9+vesXzJw5M+j6furUqdiSJUu6dhw9ejS2UKFC7j3oOHpdj/bPnj17bIECBYK2Rx555Jx2hqP+UYsWLeI8D3rsiiuuiE2s0D5afFLaj2zQoEHsP//5z3Pej79/dPHFF8dOnz49aB/1z/Rc6dmzZ+wNN9wQ1N8FsjIypQAki7KCNKqjmgea76/ik/v373fpzJoGp8dC07hDafqXf/RNI3bKYlKmlEbItCn9WmnRqkdw8OBB27t3r914441hj6fRKBUk1+bRVDyNqOkxj9KkvVRv//M0Jc2jDKTE0Pv2aLRM1E7R6JdS5f38t/XeNI1R2WHKdhozZoyrg5AQf9v0OWj6oPf+dA5VE8I7f9q8wqM6hx5NCUhNmgKQUIYXAACZWUr7RtpHmTnKJFctKRUkv+6662z48OHn7KupZ8qUevnll4Om6Pv5p+clRq5cuey+++6zKVOm2OzZs12BdH8/x09lF5Rt7t/UnqT2GbxyA9o0pS457U6s1OhH6qdqcsXVL1Pmmvpbmtbn74upnIPXD1PfT+dL5/DRRx+1Tz/9NE3eL5BRZL6KvQAiQh0H1T7SlDulO+uCq+lo2vS7Aj+hq7uEUh0lv6NHj7pgidKYQymIpJTz1BD6uimhDpzH62DpfCSWOn7qkGia3cyZM13hUqWLq/ZCcugcKsAVrr6TFzRL7XPgddJUowsAgKwqNfpG6lcoEKVNpQQUzFCwR7+HTqNTAElBKe0TOv1LASX/gJyfd7/2CaUpfAq6qFZkaC0rP7XFm/aWFGfPnnV1PBW082ovaZVA77177VIdLp1Hfz8rpfLly2dpTf0wUd2s0OCVFs2R2rVr286dO10Bd9XWUokFFaX/z3/+k+btA9IjMqUAJItqHmiUR/UP3nvvPfe7im6rsKZ+1+NJpYu0OioqtqmOjn/TcsDKoFKnSyOI4aigpAqla/OoZoLqLGmkKy7e8/xZSqGr0iSHRsDWrl0bdF/obVH9Jy0BrYKiOoeqAxEff9vU0VW9Kr0H7xyqw6vzFHoOUzsQ5fFWCGrbtm2aHB8AgKzaN1L/Rdf6cMW0NVinAtmqkxS6KIxWuVPAI7RulIJlo0ePdscNrTflBda0KSh17733WmpTXaU///wz0Ge44IILAv0UBe1Er6vgTmitJo/6dcmRGv1I7aP6o3H1y5QVp8x7ZbyF9sP8g3eqC6ZaVQpeaVBStU5VywrIisiUApAs6jgoJV1FtFUUUllCCoaok+HPyEkKFdPUKis6nkYFtVqLRhxVDLN///7utopLaslkBa6U8q1ioCrWrdVpNMqkKYE6jjqA6sSpSKYKiWuKW1z0PI3KqfimXv/IkSOugGhKqU1aDlmvrZVj1OlQQfOLLrrIPa5RsjfeeMNuu+0214HRdD8F5e6///54jztu3Di75JJLXMdIHUt17rzRTBXvVAdHK/PonGmKoKZEasU+jUZ6o3TJpXOqz12dWhVX1+qBGqHVioIqwA4AQFaV0r6RVsfV9Vv9Bq0kp4CIiqQ3adLEBTHC0cp4yshRUXUFRDwqZv7RRx+57GktyKJ91C4V3VamlAJWcU27X7p0qctSiq+guNcf8NPx/G34+++/3T7a95dffrEPPvjA9Vu6devm3lNc1Fb1YbSoy549e+wf//iH6yepP6PFWa699lrr1auXJUdK+5F6XU2/022tqKjsfn3GXt9OnnnmGZcFrwFVLdZz8uRJVxRd/bW+ffu6Ivj6PmhQUoFFTZVUIDMlBdyBjIygFIBkU0BC6ddazlar5SlolNyAlLd08PLly12KulbDU0dBI2ia++91xhQ40mihOjWPP/64q82gugteZ0gdMHUsVJdBF3p1Bl5//fV4X1f7qaOk+f+q+aRRNK2MouemhDo1GilTO9VmpWerI6Oljr33qywjjRoqwKNzp6DSI488Eu9xtRSxNo26auRNK7h4NSrUaVPnSudQSzurI6ROst5Lakx/VMdL7VRwS50tjRwqy0sdTNW3AAAgK0tJ30g1JtUnUCBKAR1d02+99Va3klt8NGVfg19+en0FlxSE0vE0yKdMIQWDlNmjDK64JCaz2usP+Kkf4M/o0iCZNk31U5BNJRo0QKcgU0L0nrS/BuIUiNJg2MUXX+z6fOoLJldK+5HKblJtKAXNdBwFHNUHWrhwYWCfhx56yPXxNNCpATudTwW7evfu7R7X5zBy5Eg3EKn+lL4vyqJLrTIVQEaTTdXOo90IAMgqtDyzRsPefffdJD9XqflK/d6wYYPLTAIAAACAjIxMKQBIIxrl1OieRj41Evbvf//bpcurkDkAAAAAZHUEpQAgjSgNXOnYzz33nEvxVuFzFbJUzQIAAAAAyOqYvgcAAAAAAICIo5oaAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAijqAUAAAAAAAAIo6gFAAAAAAAACKOoBQAAAAAAAAs0v4Pq/l8uv7G9vEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -886,51 +972,106 @@ "output_type": "stream", "text": [ "\n", - "✅ dataset.patients is built. No signals loaded yet — only metadata + file paths.\n" + "Unique SNOMED-CT codes in dataset : 50\n", + "Total code occurrences : 56,129\n", + "\n", + "Top 10 most common codes:\n", + " 426783006 × 18,092\n", + " 164865005 × 5,261\n", + " 39732003 × 5,146\n", + " 164951009 × 3,389\n", + " 164873001 × 2,359\n", + " 164934002 × 2,345\n", + " 164861001 × 2,175\n", + " 445118002 × 1,626\n", + " 164889003 × 1,514\n", + " 164884008 × 1,154\n", + "\n", + "✅ dataset.patients built. No signals loaded yet — only metadata + file paths.\n" ] } ], "source": [ - "# ── STEP 5: Inspect the patients dictionary ──────────────────────────────────\n", "\n", - "print(f\"Type of dataset.patients : {type(dataset.patients)}\")\n", - "print(f\"Number of patients : {len(dataset.patients):,}\\n\")\n", + "# ── STEP 5: Inspect the patients dictionary (CinC 2020 format) ───────────────\n", + "#\n", + "# In PTB-XL v1.0.3 native format: patients dict had 18,869 REAL patient IDs\n", + "# → multiple ECGs per patient, strat_fold 1-10 for guaranteed splits\n", + "#\n", + "# In CinC 2020 format (jtwells2 :: PTBXLDataset):\n", + "# → patient_id == record_id == \"HR00001\" (no true patient ID in .hea files)\n", + "# → every ECG is its own \"patient\" → exactly 1 record per patient-ID\n", + "# → no strat_fold → splits are random by recording\n", + "#\n", + "# This is a fundamental design decision in jtwells2's file: the Challenge 2020\n", + "# PTB-XL headers do NOT include a shared patient identifier, so the class\n", + "# treats each recording independently.\n", + "\n", + "print(f\"dataset.patients : {type(dataset.patients)}\")\n", + "print(f\"Total entries : {len(dataset.patients):,}\\n\")\n", "\n", - "# Look at the first patient\n", - "first_pid = list(dataset.patients.keys())[0]\n", - "first_recs = dataset.patients[first_pid]\n", + "first_pid = list(dataset.patients.keys())[0]\n", + "first_recs = dataset.patients[first_pid]\n", "\n", - "print(f\"Patient ID : {first_pid}\")\n", - "print(f\"Number of ECG records for this patient : {len(first_recs)}\\n\")\n", - "print(\"Record #1 keys and values:\")\n", + "print(f\"Patient/Record ID : {first_pid}\")\n", + "print(f\"# records for this ID : {len(first_recs)}\")\n", + "print(\"\\nRecord field layout (jtwells2 schema):\")\n", "for k, v in first_recs[0].items():\n", - " print(f\" {k:<14}: {v}\")\n", + " print(f\" {k:<14}: {repr(v)[:80]}\")\n", "\n", - "# ── Distribution of ECGs per patient ─────────────────────────────────────────\n", + "print()\n", + "print(\"Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\")\n", + "print(\" (comma-separated binary codes — no confidence % field)\")\n", + "\n", + "# ── Distribution plots ────────────────────────────────────────────────────────\n", "ecg_counts = [len(v) for v in dataset.patients.values()]\n", "\n", + "# Count SNOMED codes per recording\n", + "code_counts = []\n", + "for recs in dataset.patients.values():\n", + " for r in recs:\n", + " codes = [c.strip() for c in str(r[\"scp_codes\"]).split(\",\") if c.strip()]\n", + " code_counts.append(len(codes))\n", + "\n", "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", "\n", - "# Left: histogram of ECGs per patient\n", - "axes[0].hist(ecg_counts, bins=range(1, max(ecg_counts) + 2),\n", + "# Left: ECGs per patient-ID (should all be 1 in CinC format)\n", + "max_cnt = max(ecg_counts)\n", + "axes[0].hist(ecg_counts,\n", + " bins=range(1, max_cnt + 2),\n", " color=\"#4a90d9\", edgecolor=\"white\", align=\"left\")\n", - "axes[0].set_title(\"ECG recordings per patient\", fontsize=12, fontweight=\"bold\")\n", - "axes[0].set_xlabel(\"# ECG recordings for one patient\")\n", - "axes[0].set_ylabel(\"# patients\")\n", - "axes[0].set_xticks(range(1, max(ecg_counts) + 1))\n", - "\n", - "# Right: strat_fold distribution\n", - "all_folds = [r[\"strat_fold\"] for recs in dataset.patients.values() for r in recs]\n", - "fold_counts = pd.Series(all_folds).value_counts().sort_index()\n", - "axes[1].bar(fold_counts.index, fold_counts.values, color=\"#e07b54\", edgecolor=\"white\")\n", - "axes[1].set_title(\"ECGs per stratification fold (1–10)\", fontsize=12, fontweight=\"bold\")\n", - "axes[1].set_xlabel(\"strat_fold\")\n", - "axes[1].set_ylabel(\"# ECG recordings\")\n", - "axes[1].set_xticks(range(1, 11))\n", + "axes[0].set_title(\"ECG recordings per patient-ID\\n(CinC: patient_id == record_id)\",\n", + " fontsize=11, fontweight=\"bold\")\n", + "axes[0].set_xlabel(\"# recordings per ID\")\n", + "axes[0].set_ylabel(\"# patient-IDs\")\n", + "axes[0].set_xticks(range(1, max_cnt + 1))\n", + "\n", + "# Right: # SNOMED-CT codes per recording\n", + "from collections import Counter\n", + "cc = Counter(code_counts)\n", + "axes[1].bar(sorted(cc.keys()), [cc[k] for k in sorted(cc.keys())],\n", + " color=\"#e07b54\", edgecolor=\"white\")\n", + "axes[1].set_title(\"SNOMED-CT Dx codes per recording\\n(# codes in '# Dx:' header line)\",\n", + " fontsize=11, fontweight=\"bold\")\n", + "axes[1].set_xlabel(\"# SNOMED-CT codes\")\n", + "axes[1].set_ylabel(\"# recordings\")\n", "\n", "plt.tight_layout()\n", "plt.show()\n", - "print(\"\\n✅ dataset.patients is built. No signals loaded yet — only metadata + file paths.\")" + "\n", + "# ── Code vocabulary ───────────────────────────────────────────────────────────\n", + "all_codes = []\n", + "for recs in dataset.patients.values():\n", + " for r in recs:\n", + " all_codes.extend([c.strip() for c in str(r[\"scp_codes\"]).split(\",\") if c.strip()])\n", + "\n", + "print(f\"\\nUnique SNOMED-CT codes in dataset : {len(set(all_codes))}\")\n", + "print(f\"Total code occurrences : {len(all_codes):,}\")\n", + "print(f\"\\nTop 10 most common codes:\")\n", + "top10 = Counter(all_codes).most_common(10)\n", + "for code, cnt in top10:\n", + " print(f\" {code} × {cnt:,}\")\n", + "print(\"\\n✅ dataset.patients built. No signals loaded yet — only metadata + file paths.\")\n" ] }, { @@ -1001,7 +1142,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "7d06120b", "metadata": {}, "outputs": [ @@ -1028,130 +1169,203 @@ } ], "source": [ - "# ── STEP 6: Task Function — updated for SNOMED-CT codes (jtwells2 format) ────\n", + "\n", + "# ── STEP 6: Task Function — aligned with jtwells2's PTBXLMultilabelClassification\n", + "#\n", + "# ┌──────────────────────────────────────────────────────────────────────────┐\n", + "# │ SOURCE FILE: PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py │\n", + "# │ CLASS: PTBXLMultilabelClassification(BaseTask) │\n", + "# │ AUTHOR: jtwells2 (CS-598 DLH Team) │\n", + "# └──────────────────────────────────────────────────────────────────────────┘\n", + "#\n", + "# jtwells2's __call__(patient) does exactly:\n", + "# 1. Load .mat signal (12, 5000) at 500 Hz\n", + "# 2. Decimate to 100 Hz: signal[:, ::5] → shape (12, 1000)\n", + "# OR keep 500 Hz: shape (12, 5000)\n", + "# 3. Parse SNOMED-CT codes from scp_codes attribute\n", + "# 4. Map codes → NORM / MI / STTC / CD / HYP via SNOMED_TO_SUPERDIAG\n", + "# 5. Return [{\"signal\": np.ndarray, \"labels\": List[str]}] (ONE per recording)\n", "#\n", - "# KEY CHANGE from PTB-XL v1.0.3 native format:\n", - "# OLD: scp_codes = {\"NORM\": 100.0, \"SR\": 0.0}\n", - "# → labels built with confidence threshold >= 50%\n", - "# NEW: scp_codes = \"426783006,251146004\"\n", - "# → all codes are positive (binary), no threshold needed\n", - "# → must map SNOMED-CT numeric codes → NORM / CD / HYP / MI / STTC\n", + "# KEY DIFFERENCES from our previous custom task function:\n", "#\n", - "# Mapping derived by cross-referencing CinC 2020 .hea Dx codes\n", - "# with PTB-XL's ptbxl_database.csv + scp_statements.csv.\n", + "# OLD (custom task) NEW (jtwells2 aligned)\n", + "# ───────────────────────────── ──────────────────────────────────────\n", + "# Sliding 2.5s windows @ 500Hz Full 10s recording, decimated to 100Hz\n", + "# ~7 windows per ECG → ~152k 1 sample per recording → ~19k samples\n", + "# \"label\" key (singular) \"labels\" key (plural, jtwells2 schema)\n", + "# 50-code hand-built SNOMED map jtwells2's 46-code clinically correct map\n", + "# confidence threshold none binary (same — CinC codes are all +ve)\n", + "# NORM mapped too broadly NORM = only 426783006 (correct NSR code)\n", + "#\n", + "# WHY epoch_path AND NOT direct signal array?\n", + "# Installed pyhealth 1.1.6 SampleSignalDataset.__getitem__ REQUIRES epoch_path\n", + "# for lazy signal loading. We write one .pkl per recording and store epoch_path\n", + "# identically to the installed pyhealth convention.\n", "\n", "from scipy.io import loadmat as scipy_loadmat\n", "\n", - "# ── SNOMED-CT numeric code → superdiagnostic class ───────────────────────────\n", + "# ── SNOMED_TO_SUPERDIAG dict ──────────────────────────────────────────────────\n", + "# Direct copy from jtwells2's ptbxl_multilabel_classification.py\n", + "# Clinically correct mapping from Table 1 of Strodthoff et al. (2020)\n", "SNOMED_TO_SUPERDIAG = {\n", - " # NORM\n", - " \"426783006\": \"NORM\", \"164884008\": \"NORM\", \"427393009\": \"NORM\",\n", - " \"164947007\": \"NORM\", \"47665007\": \"NORM\", \"251146004\": \"NORM\",\n", - " \"164931005\": \"NORM\",\n", - " # CD — Conduction Disturbance\n", - " \"270492004\": \"CD\", \"195042002\": \"CD\", \"164865005\": \"CD\",\n", - " \"426177001\": \"CD\", \"698252002\": \"CD\", \"39732003\": \"CD\",\n", - " \"445118002\": \"CD\", \"74390002\": \"CD\", \"713426002\": \"CD\",\n", - " \"713427006\": \"CD\", \"54329005\": \"CD\", \"445211001\": \"CD\",\n", - " \"251120003\": \"CD\", \"251200008\": \"CD\", \"27885002\": \"CD\",\n", - " \"251180001\": \"CD\", \"164909002\": \"CD\", \"428750005\": \"CD\",\n", - " \"426434006\": \"CD\", \"284470004\": \"CD\",\n", - " # HYP — Hypertrophy\n", - " \"164861001\": \"HYP\", \"164873001\": \"HYP\", \"164934002\": \"HYP\",\n", - " \"67741000119109\": \"HYP\", \"427084000\": \"HYP\", \"446358003\": \"HYP\",\n", - " \"266249003\": \"HYP\", \"89792004\": \"HYP\", \"164890007\": \"HYP\",\n", - " \"426761007\": \"HYP\",\n", - " # MI — Myocardial Infarction\n", - " \"164917005\": \"MI\", \"10370003\": \"MI\",\n", - " # STTC — ST/T-wave change\n", - " \"425623009\": \"STTC\", \"55930002\": \"STTC\", \"164951009\": \"STTC\",\n", - " \"164889003\": \"STTC\", \"429622005\": \"STTC\", \"425419005\": \"STTC\",\n", - " \"111975006\": \"STTC\", \"63593006\": \"STTC\", \"59931005\": \"STTC\",\n", - " \"11157007\": \"STTC\", \"67198005\": \"STTC\",\n", + " # ── NORM: Normal sinus rhythm only ──────────────────────────────────── #\n", + " \"426783006\": \"NORM\", # Normal sinus rhythm\n", + "\n", + " # ── MI: Myocardial Infarction ────────────────────────────────────────── #\n", + " \"57054005\": \"MI\", # Acute myocardial infarction\n", + " \"164865005\": \"MI\", # Myocardial infarction (generic)\n", + " \"413444003\": \"MI\", # Acute MI of anterolateral wall\n", + " \"413867000\": \"MI\", # Acute MI of inferior wall\n", + " \"164861001\": \"MI\", # Anterior MI\n", + " \"164857002\": \"MI\", # Inferior MI\n", + " \"164860000\": \"MI\", # Anteroseptal MI\n", + " \"164864009\": \"MI\", # Posterior MI\n", + " \"164867002\": \"MI\", # Lateral MI\n", + "\n", + " # ── STTC: ST/T-wave Change ───────────────────────────────────────────── #\n", + " \"164931005\": \"STTC\", # ST elevation\n", + " \"164934002\": \"STTC\", # ST depression\n", + " \"59931005\": \"STTC\", # T-wave abnormality / inverted T-wave\n", + " \"164947007\": \"STTC\", # Prolonged PR interval\n", + " \"164917005\": \"STTC\", # Prolonged QT interval\n", + " \"251268003\": \"STTC\", # Early repolarisation pattern\n", + " \"428750005\": \"STTC\", # Non-specific ST-T change\n", + "\n", + " # ── CD: Conduction Disturbance / Rhythm Disorder ─────────────────────── #\n", + " \"270492004\": \"CD\", # First-degree AV block\n", + " \"195042002\": \"CD\", # Second-degree AV block\n", + " \"27885002\": \"CD\", # Third-degree AV block (complete heart block)\n", + " \"6374002\": \"CD\", # Bundle branch block (unspecified)\n", + " \"713427006\": \"CD\", # Complete right bundle branch block (CRBBB)\n", + " \"713426002\": \"CD\", # Complete left bundle branch block (CLBBB)\n", + " \"164909002\": \"CD\", # Left bundle branch block\n", + " \"59118001\": \"CD\", # Right bundle branch block\n", + " \"698252002\": \"CD\", # Non-specific intraventricular conduction disturbance\n", + " \"445118002\": \"CD\", # Left anterior fascicular block (LAFB)\n", + " \"10370003\": \"CD\", # Pacing rhythm\n", + " \"164889003\": \"CD\", # Atrial fibrillation\n", + " \"164890007\": \"CD\", # Atrial flutter\n", + " \"426627000\": \"CD\", # Bradycardia\n", + " \"427393009\": \"CD\", # Sinus arrhythmia\n", + " \"426177001\": \"CD\", # Sinus bradycardia\n", + " \"427084000\": \"CD\", # Sinus tachycardia\n", + " \"63593006\": \"CD\", # Supraventricular premature beats\n", + " \"17338001\": \"CD\", # Ventricular premature beats\n", + " \"284470004\": \"CD\", # Premature atrial contraction\n", + " \"427172004\": \"CD\", # Premature ventricular contraction\n", + "\n", + " # ── HYP: Hypertrophy / Axis Deviation ───────────────────────────────── #\n", + " \"55827005\": \"HYP\", # Left ventricular hypertrophy\n", + " \"446358003\": \"HYP\", # Right ventricular hypertrophy\n", + " \"73282002\": \"HYP\", # Biventricular hypertrophy\n", + " \"67751000119106\": \"HYP\", # Left atrial enlargement\n", + " \"446813000\": \"HYP\", # Right atrial enlargement\n", + " \"39732003\": \"HYP\", # Left axis deviation\n", + " \"47665007\": \"HYP\", # Right axis deviation\n", + " \"251146004\": \"HYP\", # Low QRS voltage\n", "}\n", "\n", - "SUPERDIAG_CLASSES = [\"NORM\", \"CD\", \"HYP\", \"MI\", \"STTC\"]\n", + "# Ordered class list — from jtwells2's SUPERDIAG_CLASSES\n", + "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", "\n", "\n", - "def ptbxl_superdiagnostic_fn(record_list: list,\n", - " epoch_sec: float = 2.5,\n", - " freq: int = 500) -> list:\n", + "# ── Task function — mirrors PTBXLMultilabelClassification.__call__() ──────────\n", + "def ptbxl_superdiagnostic_fn(\n", + " record_list: list,\n", + " sampling_rate: int = 100, # jtwells2 default\n", + " native_freq: int = 500, # CinC 2020 native rate\n", + ") -> list:\n", " \"\"\"\n", - " Task function — updated for jtwells2's CinC 2020 format.\n", + " Task function aligned with jtwells2's PTBXLMultilabelClassification.__call__().\n", + "\n", + " SIGNAL: full 10-second ECG decimated to 100 Hz → shape (12, 1000)\n", + " Matches jtwells2: signal = mat[\"val\"] ; signal[:, ::5]\n", + "\n", + " LABELS: \"labels\" key (plural) → List[str] of superdiagnostic class names\n", + " Matches jtwells2 output schema: {\"signal\": ..., \"labels\": [...]}\n", "\n", - " scp_codes is now a SNOMED-CT comma-separated string (no confidence).\n", - " All codes listed are treated as positive (binary labels).\n", + " STORAGE: cached as .pkl files (epoch_path key) for installed pyhealth\n", + " SampleSignalDataset which requires lazy loading via epoch_path.\n", " \"\"\"\n", - " samples = []\n", - " win_len = int(freq * epoch_sec) # 1250 samples @ 500 Hz\n", - " stride = win_len // 2 # 50% overlap\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / \"windows\"\n", + " samples = []\n", + " decimate = native_freq // sampling_rate # 5\n", + " expected_len = 5000 // decimate # 1000 samples\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"cinc_{sampling_rate}hz\"\n", " cache_dir.mkdir(parents=True, exist_ok=True)\n", "\n", " for visit in record_list:\n", - " pid = visit[\"patient_id\"]\n", - " ecg_id = visit[\"ecg_id\"]\n", - " mat_path = visit[\"mat_path\"]\n", - " scp_codes = visit[\"scp_codes\"] # \"426783006,251146004\" (string)\n", - "\n", - " # ── 1. Map SNOMED-CT string → superdiagnostic List[str] ───────────────\n", - " snomed_codes = [c.strip() for c in str(scp_codes).split(\",\") if c.strip()]\n", - " labels = list({\n", - " SNOMED_TO_SUPERDIAG[code]\n", - " for code in snomed_codes\n", - " if code in SNOMED_TO_SUPERDIAG\n", - " })\n", + " pid = visit[\"patient_id\"]\n", + " ecg_id = visit[\"ecg_id\"]\n", + " mat_path = visit[\"mat_path\"]\n", + "\n", + " # ── 1. Parse SNOMED-CT codes → superdiagnostic labels ─────────────\n", + " raw = str(visit[\"scp_codes\"])\n", + " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", + " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", " if not labels:\n", - " continue\n", + " continue # skip recordings with no mappable diagnosis\n", "\n", - " # ── 2. Load signal ─────────────────────────────────────────────────────\n", + " # ── 2. Load signal (mirrors jtwells2's scipy.io.loadmat(signal_file)) ─\n", " if mat_path and Path(mat_path).exists():\n", " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV, (12, 5000)\n", " else:\n", - " t = np.linspace(0, 10, freq * 10)\n", - " lead = 0.5 * np.sin(2 * np.pi * 1.2 * t) + np.random.randn(freq * 10) * 0.04\n", + " t = np.linspace(0, 10, native_freq * 10)\n", + " lead = 0.5*np.sin(2*np.pi*1.2*t) + np.random.randn(native_freq*10)*0.04\n", " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", "\n", - " # ── 3. Sliding-window segmentation ────────────────────────────────────\n", - " n_windows = max(1, (signal.shape[1] - win_len) // stride + 1)\n", - " for idx in range(n_windows):\n", - " s = idx * stride\n", - " window = signal[:, s : s + win_len]\n", - " if window.shape[1] < win_len:\n", - " break\n", - " pkl_path = str(cache_dir / f\"{pid}_{ecg_id}_{idx}.pkl\")\n", + " # ── 3. Decimate to target sampling rate (mirrors jtwells2: signal[:, ::5])\n", + " signal = signal[:, ::decimate] # → (12, 1000)\n", + "\n", + " if signal.shape[1] < expected_len:\n", + " continue # malformed recording — skip\n", + "\n", + " # ── 4. Cache as .pkl — required by installed pyhealth SampleSignalDataset\n", + " pkl_path = str(cache_dir / f\"{ecg_id}.pkl\")\n", + " if not Path(pkl_path).exists(): # skip if already cached\n", " with open(pkl_path, \"wb\") as f:\n", - " pickle.dump({\"signal\": window}, f)\n", - " samples.append({\n", - " \"patient_id\": pid,\n", - " \"record_id\": ecg_id,\n", - " \"ecg_id\": ecg_id,\n", - " \"epoch_path\": pkl_path,\n", - " \"label\": labels,\n", - " })\n", + " pickle.dump({\"signal\": signal}, f)\n", + "\n", + " samples.append({\n", + " \"patient_id\": pid,\n", + " \"record_id\": ecg_id,\n", + " \"ecg_id\": ecg_id,\n", + " \"epoch_path\": pkl_path, # installed SampleSignalDataset requirement\n", + " \"labels\": labels, # \"labels\" key — jtwells2 schema\n", + " })\n", " return samples\n", "\n", "\n", "# ── Apply task ────────────────────────────────────────────────────────────────\n", "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\")\n", - "print(\"(SNOMED-CT codes from CinC .hea files — binary labels, no threshold)\\n\")\n", + "print(\" Signal : full 10-second ECG, decimated 500→100 Hz → (12, 1000)\")\n", + "print(\" Labels : 'labels' key [jtwells2 schema]\")\n", + "print(\" Mapping : SNOMED_TO_SUPERDIAG from ptbxl_multilabel_classification.py\\n\")\n", + "\n", "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "sample_dataset.input_info[\"label\"] = {\"type\": str, \"dim\": 2}\n", + "sample_dataset.input_info[\"labels\"] = {\"type\": str, \"dim\": 2} # \"labels\" key\n", "\n", "n = len(sample_dataset)\n", - "pos_rates = np.zeros(5)\n", + "pos_rates = np.zeros(len(SUPERDIAG_CLASSES))\n", "for s in sample_dataset.samples:\n", - " for cls in s[\"label\"]:\n", - " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", - "pos_rates /= n\n", + " for cls in s[\"labels\"]:\n", + " if cls in SUPERDIAG_CLASSES:\n", + " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", + "pos_rates /= max(n, 1)\n", "\n", - "print(f\"\\nSampleSignalDataset: {n:,} samples\")\n", + "print(f\"SampleSignalDataset: {n:,} samples (one per recording, no sliding windows)\")\n", "print(f\" input_info: {sample_dataset.input_info}\")\n", - "print(f\"\\nLabel prevalence (binary SNOMED-CT mapping):\")\n", + "print(f\"\\nLabel prevalence (jtwells2 SNOMED_TO_SUPERDIAG):\")\n", "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", " bar = \"█\" * int(rate * 30)\n", - " print(f\" {cls:<6} {rate*100:5.1f}% {bar}\")\n" + " print(f\" {cls:<6} {rate*100:5.1f}% {bar}\")\n", + "\n", + "# Verify schema matches jtwells2's PTBXLMultilabelClassification output\n", + "sample0 = sample_dataset.samples[0]\n", + "print(f\"\\nSample dict keys : {list(sample0.keys())}\")\n", + "print(f\" epoch_path : ...{sample0['epoch_path'][-40:]}\")\n", + "print(f\" labels : {sample0['labels']}\")\n", + "print(f\"\\n✅ Task applied. Schema: epoch_path + 'labels' (jtwells2 / PTBXLMultilabelClassification)\")\n" ] }, { @@ -1190,33 +1404,39 @@ } ], "source": [ - "# ── STEP 7: Visualize a saved window from disk ────────────────────────────────\n", + "\n", + "# ── STEP 7: Visualize a sample window and its multi-hot label ─────────────────\n", "#\n", - "# The pickle files written by ptbxl_superdiagnostic_fn contain ONLY:\n", - "# {\"signal\": np.float32(12, 1250)}\n", - "# The \"label\" (List[str]) lives in the outer sample dict — NOT in the pickle.\n", - "# We convert the List[str] label → multi-hot float array for the bar chart.\n", + "# Schema after jtwells2 alignment:\n", + "# sample[\"epoch_path\"] → .pkl file with {\"signal\": np.float32(12, 1000)}\n", + "# sample[\"labels\"] → List[str] e.g. [\"NORM\"] or [\"CD\", \"MI\"]\n", + "# (key is \"labels\", NOT \"label\")\n", + "#\n", + "# Signal shape is now (12, 1000) at 100 Hz (full 10-second recording),\n", + "# vs the old (12, 1250) at 500 Hz (2.5-second window). This matches\n", + "# jtwells2's PTBXLMultilabelClassification with sampling_rate=100.\n", "\n", "def visualize_sample(sample: dict):\n", - " \"\"\"Plot the 12-lead ECG window and the multi-hot label bar chart.\"\"\"\n", - " # Load signal from pickle\n", + " \"\"\"Plot the 12-lead ECG and multi-hot label bar for one sample.\"\"\"\n", + " # ── Load signal from epoch_path pickle ────────────────────────────────\n", " with open(sample[\"epoch_path\"], \"rb\") as f:\n", " data = pickle.load(f)\n", "\n", - " signal = data[\"signal\"] # np.float32 (12, 1250)\n", - " label_list = sample[\"label\"] # List[str] e.g. [\"NORM\"] or [\"CD\",\"MI\"]\n", + " signal = data[\"signal\"] # (12, 1000) float32 @ 100 Hz\n", + " label_list = sample[\"labels\"] # ← \"labels\" key (jtwells2 schema)\n", "\n", - " # Convert List[str] → multi-hot float array for plotting\n", + " # Convert List[str] → multi-hot for the bar chart\n", " label_vec = [1.0 if cls in label_list else 0.0 for cls in SUPERDIAG_CLASSES]\n", "\n", " fig = plt.figure(figsize=(15, 9))\n", " gs = gridspec.GridSpec(2, 1, figure=fig, height_ratios=[4, 1], hspace=0.4)\n", "\n", - " # ── Top panel: 12-lead ECG ────────────────────────────────────────────────\n", + " # ── Top: 12-lead ECG ──────────────────────────────────────────────────\n", " gs_top = gridspec.GridSpecFromSubplotSpec(6, 2, subplot_spec=gs[0],\n", " hspace=0.05, wspace=0.3)\n", " lead_names = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", - " t_axis = np.arange(signal.shape[1]) / 500.0 # seconds\n", + " fs = 100 # jtwells2: 100 Hz\n", + " t_axis = np.arange(signal.shape[1]) / fs # 0 … 10 seconds\n", "\n", " for i in range(12):\n", " row, col = divmod(i, 2)\n", @@ -1229,41 +1449,49 @@ " else:\n", " ax.set_xlabel(\"Time (s)\", fontsize=8)\n", "\n", + " # scp_codes is a SNOMED-CT string in CinC format\n", " patient_scp = dataset.patients[sample[\"patient_id\"]][0][\"scp_codes\"]\n", - " fig.text(0.5, 0.96,\n", - " f\"2.5-second ECG window — patient {sample['patient_id']}, \"\n", - " f\"ecg_id {sample['ecg_id']} | shape: {signal.shape}\",\n", - " ha=\"center\", fontsize=11, fontweight=\"bold\")\n", - "\n", - " # ── Bottom panel: multi-hot label bar chart ───────────────────────────────\n", - " ax_label = fig.add_subplot(gs[1])\n", - " colors = [\"#2ecc71\" if v == 1.0 else \"#e74c3c\" for v in label_vec]\n", - " bars = ax_label.bar(SUPERDIAG_CLASSES, label_vec, color=colors,\n", - " edgecolor=\"white\", width=0.6)\n", - "\n", - " for bar, val in zip(bars, label_vec):\n", - " status = \"✓ ACTIVE\" if val == 1.0 else \"✗ absent\"\n", - " ax_label.text(bar.get_x() + bar.get_width()/2, val + 0.03,\n", - " status, ha=\"center\", va=\"bottom\", fontsize=9,\n", - " color=\"#2ecc71\" if val == 1.0 else \"#aaaaaa\")\n", - "\n", - " ax_label.set_ylim(0, 1.5)\n", - " ax_label.set_ylabel(\"Label value\\n(0 or 1)\", fontsize=9)\n", - " ax_label.set_title(\n", - " f\"Multi-hot label: {label_list} | original SCP codes: {list(patient_scp.keys())}\",\n", - " fontsize=9)\n", - " ax_label.set_yticks([0, 1])\n", - " ax_label.legend(handles=[\n", + " fig.text(\n", + " 0.5, 0.97,\n", + " f\"Full 10-second ECG @ 100 Hz — patient {sample['patient_id']} \"\n", + " f\"| shape: {signal.shape} (12 leads × 1000 samples)\",\n", + " ha=\"center\", fontsize=11, fontweight=\"bold\",\n", + " )\n", + "\n", + " # ── Bottom: multi-hot label bar ───────────────────────────────────────\n", + " ax_lbl = fig.add_subplot(gs[1])\n", + " colors = [\"#2ecc71\" if v else \"#e74c3c\" for v in label_vec]\n", + " bars = ax_lbl.bar(SUPERDIAG_CLASSES, label_vec,\n", + " color=colors, edgecolor=\"white\", width=0.6)\n", + " for bar_, val in zip(bars, label_vec):\n", + " ax_lbl.text(\n", + " bar_.get_x() + bar_.get_width() / 2, val + 0.03,\n", + " \"✓ ACTIVE\" if val else \"✗ absent\",\n", + " ha=\"center\", va=\"bottom\", fontsize=9,\n", + " color=\"#2ecc71\" if val else \"#aaaaaa\",\n", + " )\n", + " ax_lbl.set_ylim(0, 1.5)\n", + " ax_lbl.set_ylabel(\"Label (0/1)\", fontsize=9)\n", + " ax_lbl.set_title(\n", + " f\"'labels': {label_list} | SNOMED-CT Dx: {patient_scp}\",\n", + " fontsize=9,\n", + " )\n", + " ax_lbl.set_yticks([0, 1])\n", + " ax_lbl.legend(handles=[\n", " mpatches.Patch(color=\"#2ecc71\", label=\"Active class (label=1)\"),\n", - " mpatches.Patch(color=\"#e74c3c\", label=\"Inactive class (label=0)\"),\n", + " mpatches.Patch(color=\"#e74c3c\", label=\"Inactive (label=0)\"),\n", " ], loc=\"upper right\", fontsize=8)\n", "\n", " plt.show()\n", - " print(f\"\\n signal shape : {signal.shape} (12 leads × 1250 samples @ 500 Hz = 2.5 s)\")\n", - " print(f\" label : {label_list} → multi-hot: {label_vec}\")\n", + "\n", + " # Summary\n", + " print(f\" signal shape : {signal.shape} (12 leads × 1000 samples @ 100 Hz = 10 s)\")\n", + " print(f\" labels : {label_list}\")\n", + " print(f\" multi-hot : {label_vec} [{', '.join(SUPERDIAG_CLASSES)}]\")\n", + " print(f\" SNOMED-CT Dx : {patient_scp}\")\n", + " print(f\"\\n Schema key 'labels' (plural) matches jtwells2 :: PTBXLMultilabelClassification\")\n", "\n", "\n", - "# Pick the first sample and visualize\n", "visualize_sample(sample_dataset.samples[0])\n" ] }, @@ -1298,7 +1526,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "036f2200", "metadata": {}, "outputs": [ @@ -1324,50 +1552,53 @@ } ], "source": [ + "\n", "# ── STEP 8: Patient-level split + PyHealth DataLoaders ───────────────────────\n", "#\n", - "# Why patient-level split?\n", - "# Splitting by sample risks putting windows from the same recording in both\n", - "# train and test — the model sees the same patient twice → inflated metrics.\n", - "# split_by_patient() assigns ALL windows from one patient to a single split.\n", + "# With CinC 2020 format: patient_id == record_id (each ECG is its own ID),\n", + "# so \"patient-level split\" is effectively equivalent to \"record-level split\".\n", + "# The split still prevents any artificial duplicate leakage.\n", + "#\n", + "# split_by_patient(dataset, ratios, seed):\n", + "# → Assigns all samples from one patient_id to exactly one split\n", + "# → Returns three torch.utils.data.Subset objects\n", "#\n", - "# PyHealth API used:\n", - "# split_by_patient(dataset, ratios, seed)\n", - "# • returns three torch.utils.data.Subset objects (train / val / test)\n", - "# • internally indexes by patient_to_index built in SampleSignalDataset\n", + "# get_dataloader(dataset, batch_size, shuffle):\n", + "# → Wraps Subset in DataLoader with collate_fn_dict\n", + "# → collate_fn_dict returns {key: list_of_values} per batch\n", + "# → SampleSignalDataset.__getitem__ loads signal from epoch_path before return\n", "#\n", - "# get_dataloader(dataset, batch_size, shuffle)\n", - "# • wraps Subset in torch DataLoader with collate_fn_dict\n", - "# • collate_fn_dict returns {key: list_of_values} — SparcNet handles\n", - "# the list-of-arrays → tensor conversion internally in forward()\n", + "# Batch after collation:\n", + "# batch[\"signal\"] → list of np.ndarray (12, 1000), one per sample\n", + "# batch[\"labels\"] → list of List[str], \"labels\" key (jtwells2)\n", + "# batch[\"patient_id\"] → list of str\n", "\n", "train_ds, val_ds, test_ds = split_by_patient(\n", - " dataset = sample_dataset,\n", - " ratios = [0.8, 0.1, 0.1],\n", - " seed = 42,\n", + " dataset = sample_dataset,\n", + " ratios = [0.8, 0.1, 0.1],\n", + " seed = 42,\n", ")\n", "\n", - "BATCH_SIZE = 32\n", + "BATCH_SIZE = 32\n", "train_loader = get_dataloader(train_ds, batch_size=BATCH_SIZE, shuffle=True)\n", "val_loader = get_dataloader(val_ds, batch_size=BATCH_SIZE, shuffle=False)\n", "test_loader = get_dataloader(test_ds, batch_size=BATCH_SIZE, shuffle=False)\n", "\n", - "# ── Verify split sizes ────────────────────────────────────────────────────────\n", "print(\"PyHealth patient-level split (seed=42):\")\n", "print(f\" Train : {len(train_ds):>6,} samples ({len(train_ds)/len(sample_dataset):.1%})\")\n", "print(f\" Val : {len(val_ds):>6,} samples ({len(val_ds)/len(sample_dataset):.1%})\")\n", "print(f\" Test : {len(test_ds):>6,} samples ({len(test_ds)/len(sample_dataset):.1%})\")\n", - "print(f\"\\n Batches / epoch : {len(train_loader)}\")\n", - "print(f\" Batch size : {BATCH_SIZE}\")\n", + "print(f\"\\n Batches / epoch : {len(train_loader)}\")\n", + "print(f\" Batch size : {BATCH_SIZE}\")\n", "\n", - "# ── Peek at one batch to confirm shapes ──────────────────────────────────────\n", + "# ── Peek at one batch ─────────────────────────────────────────────────────────\n", "batch = next(iter(train_loader))\n", - "print(f\"\\nSample batch keys : {list(batch.keys())}\")\n", - "print(f\" signal : list × {len(batch['signal'])} \"\n", - " f\"shapes e.g. {np.array(batch['signal'][0]).shape} (12 leads × 1250 samples)\")\n", - "print(f\" label first item : {batch['label'][0]} (List[str])\")\n", + "print(f\"\\nSample batch keys : {list(batch.keys())}\")\n", + "print(f\" signal : list × {len(batch['signal'])} arrays, \"\n", + " f\"e.g. {np.array(batch['signal'][0]).shape} (12 leads × 1000 samples @ 100 Hz)\")\n", + "print(f\" labels : {batch['labels'][0]} (List[str] — jtwells2 'labels' key)\")\n", "\n", - "# ── Leak check : no patient in two splits ─────────────────────────────────────\n", + "# ── Leak check ────────────────────────────────────────────────────────────────\n", "def patient_ids(subset):\n", " ds = subset.dataset\n", " return {ds.samples[i][\"patient_id\"] for i in subset.indices}\n", @@ -1379,9 +1610,8 @@ "assert len(train_pts & val_pts) == 0, \"LEAKAGE: train ∩ val!\"\n", "assert len(train_pts & test_pts) == 0, \"LEAKAGE: train ∩ test!\"\n", "assert len(val_pts & test_pts) == 0, \"LEAKAGE: val ∩ test!\"\n", - "print(f\"\\n✅ Zero patient overlap across splits — no data leakage.\")\n", - "print(f\" Train patients : {len(train_pts):,} \"\n", - " f\"| Val : {len(val_pts):,} | Test : {len(test_pts):,}\")\n" + "print(f\"\\n✅ Zero patient overlap across splits.\")\n", + "print(f\" Train IDs : {len(train_pts):,} | Val : {len(val_pts):,} | Test : {len(test_pts):,}\")\n" ] }, { @@ -1422,7 +1652,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "90b71e50", "metadata": {}, "outputs": [ @@ -1452,71 +1682,66 @@ } ], "source": [ + "\n", "# ── STEP 9: PyHealth Models ───────────────────────────────────────────────────\n", "#\n", - "# Model A — SparcNet (from pyhealth.models)\n", - "# ─────────────────────────────────────────\n", - "# SparcNet is PyHealth's built-in DenseNet-based 1-D signal classifier.\n", - "# • Architecture: 1D DenseNet (Dense blocks + Transition layers)\n", - "# adapted from Jin Jing et al., Neurology 2023\n", - "# • Input: (batch, 12 leads, 1250 samples) → batch of ECG windows\n", - "# • Output dict: {\"loss\": scalar, \"y_prob\": (B,K), \"y_true\": (B,K), ...}\n", - "# • Constructed from SampleSignalDataset so it auto-detects n_channels & length\n", - "# • mode=\"multilabel\" → BCEWithLogitsLoss + sigmoid output\n", + "# Both models are constructed from sample_dataset to auto-detect:\n", + "# feature_keys = [\"signal\"] → input tensor (B, 12, 1000)\n", + "# label_key = \"labels\" → \"labels\" key (jtwells2 schema)\n", + "# mode = \"multilabel\" → BCEWithLogitsLoss + sigmoid\n", "#\n", - "# Model B — BiLSTMECG (custom PyHealth BaseModel subclass)\n", - "# ────────────────────────────────────────────────────────\n", - "# A bidirectional-LSTM classifier that extends pyhealth.models.BaseModel.\n", - "# • By extending BaseModel it inherits prepare_labels, prepare_y_prob,\n", - "# get_loss_function, and Trainer compatibility — no boilerplate needed.\n", - "# • Input: same shape as SparcNet\n", - "# • Output: same dict format {\"loss\", \"y_prob\", \"y_true\", \"logit\"}\n", + "# Signal shape change vs previous run:\n", + "# OLD: (12, 1250) @ 500 Hz — 2.5-second windows\n", + "# NEW: (12, 1000) @ 100 Hz — full 10-second recordings decimated to 100 Hz\n", + "# (matches jtwells2's PTBXLMultilabelClassification)\n", "#\n", - "# Both models are interchangeable with PyHealth's Trainer and evaluation APIs.\n", + "# Label key change:\n", + "# OLD: label_key = \"label\" (singular)\n", + "# NEW: label_key = \"labels\" (plural — jtwells2 schema)\n", "\n", "import math\n", "from collections import OrderedDict\n", "\n", "# ── Model A: SparcNet ─────────────────────────────────────────────────────────\n", + "# Input : (B, 12, 1000) — 12 leads × 1000 samples (100 Hz, full 10s ECG)\n", + "# Output: (B, 5) — 5 superdiagnostic class scores\n", "sparcnet = SparcNet(\n", - " dataset = sample_dataset, # SampleSignalDataset (for input_info)\n", - " feature_keys = [\"signal\"], # key in the sample dict\n", - " label_key = \"label\", # key holding the List[str] labels\n", - " mode = \"multilabel\", # BCEWithLogitsLoss + sigmoid\n", + " dataset = sample_dataset,\n", + " feature_keys = [\"signal\"],\n", + " label_key = \"labels\", # ← \"labels\" key (jtwells2 schema)\n", + " mode = \"multilabel\",\n", ")\n", "\n", "print(\"Model A — PyHealth SparcNet\")\n", "n_params_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", "print(f\" Trainable params : {n_params_sparcnet:,}\")\n", - "print(f\" Input shape : (B, 12, 1250) — 12 leads × 1250 samples per window\")\n", - "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) — 5 superdiagnostic class scores\")\n", + "print(f\" Input shape : (B, 12, 1000) — 12 leads × 1000 samples @ 100 Hz\")\n", + "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) — {SUPERDIAG_CLASSES}\")\n", + "print(f\" label_key : 'labels' [jtwells2 schema]\")\n", "\n", "\n", - "# ── Model B: BiLSTMECG — custom PyHealth BaseModel ───────────────────────────\n", - "\n", + "# ── Model B: BiLSTMECG ────────────────────────────────────────────────────────\n", "class BiLSTMECG(BaseModel):\n", " \"\"\"\n", " Bidirectional LSTM ECG classifier extending pyhealth.models.BaseModel.\n", "\n", - " By inheriting BaseModel we get for free:\n", - " • prepare_labels() — str labels → multi-hot tensor\n", - " • prepare_y_prob() — logits → sigmoid probabilities \n", - " • get_loss_function()— BCEWithLogitsLoss for multilabel\n", - " • Trainer compatibility (forward must return the standard dict)\n", + " Inputs are (B, 12, 1000) at 100 Hz (full 10-second recording).\n", + " Labels via label_key=\"labels\" (jtwells2 schema, plural key).\n", "\n", " Architecture:\n", - " Input (B, 12, T) → permute → BiLSTM(12→256) → last state\n", - " → Linear(256→K) → sigmoid (applied by prepare_y_prob)\n", + " Input (B, 12, T) → permute (B, T, 12)\n", + " → BiLSTM(12 → hidden_size, n_layers) → last timestep (B, hidden*2)\n", + " → Linear(hidden*2 → K)\n", + " → BCEWithLogitsLoss (via BaseModel.get_loss_function)\n", " \"\"\"\n", - "\n", " def __init__(\n", " self,\n", " dataset,\n", " feature_keys,\n", " label_key,\n", " mode,\n", - " hidden_size: int = 128,\n", - " n_layers: int = 3,\n", + " hidden_size: int = 128,\n", + " n_layers: int = 3,\n", " dropout: float = 0.2,\n", " **kwargs,\n", " ):\n", @@ -1526,70 +1751,63 @@ " label_key = label_key,\n", " mode = mode,\n", " )\n", - " # Read input dimensions from SampleSignalDataset.input_info\n", - " sig_info = self.dataset.input_info[\"signal\"]\n", - " in_channels = sig_info[\"n_channels\"]\n", + " sig_info = self.dataset.input_info[\"signal\"]\n", + " in_channels = sig_info[\"n_channels\"] # 12\n", "\n", - " # Build tokenizer (BaseModel.get_label_tokenizer needs input_info dim=2)\n", " self.label_tokenizer = self.get_label_tokenizer()\n", - " output_size = self.get_output_size(self.label_tokenizer)\n", + " output_size = self.get_output_size(self.label_tokenizer)\n", "\n", " self.lstm = nn.LSTM(\n", - " input_size = in_channels,\n", - " hidden_size = hidden_size,\n", - " num_layers = n_layers,\n", - " bidirectional=True,\n", - " batch_first =True,\n", + " input_size = in_channels,\n", + " hidden_size = hidden_size,\n", + " num_layers = n_layers,\n", + " bidirectional = True,\n", + " batch_first = True,\n", " dropout = dropout if n_layers > 1 else 0.0,\n", " )\n", " self.fc = nn.Linear(hidden_size * 2, output_size)\n", "\n", " def forward(self, **kwargs) -> dict:\n", - " \"\"\"\n", - " Forward pass.\n", + " # Stack list of (12, T) arrays → tensor (B, 12, T)\n", + " x = torch.tensor(\n", + " np.array(kwargs[self.feature_keys[0]]),\n", + " device=self.device,\n", + " ).float()\n", + "\n", + " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", + " logits = self.fc(out[:, -1, :]) # (B, K) — last time step\n", "\n", - " Expects kwargs[\"signal\"] = List[np.ndarray(12, T)] (from collate_fn_dict).\n", - " Returns the standard PyHealth dict: {loss, y_prob, y_true, logit}.\n", - " \"\"\"\n", - " # Stack list of numpy arrays → tensor (B, 12, T)\n", - " x = torch.tensor(np.array(kwargs[self.feature_keys[0]]),\n", - " device=self.device).float()\n", - " # LSTM expects (B, T, C) — permute\n", - " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", - " logits = self.fc(out[:, -1, :]) # (B, K) — last time step\n", - "\n", - " # PyHealth BaseModel helpers\n", " y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer)\n", " loss = self.get_loss_function()(logits, y_true)\n", " y_prob = self.prepare_y_prob(logits)\n", - "\n", " return {\"loss\": loss, \"y_prob\": y_prob, \"y_true\": y_true, \"logit\": logits}\n", "\n", "\n", "bilstm = BiLSTMECG(\n", " dataset = sample_dataset,\n", " feature_keys = [\"signal\"],\n", - " label_key = \"label\",\n", + " label_key = \"labels\", # ← \"labels\" key (jtwells2 schema)\n", " mode = \"multilabel\",\n", " hidden_size = 128,\n", " n_layers = 3,\n", ")\n", "\n", - "print(\"\\nModel B — BiLSTMECG (custom pyhealth.models.BaseModel subclass)\")\n", + "print(\"\\nModel B — BiLSTMECG (custom BaseModel subclass)\")\n", "n_params_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", "print(f\" Trainable params : {n_params_bilstm:,}\")\n", - "print(f\" Architecture : BiLSTM(12→128, ×3 layers) → FC(256→5)\")\n", + "print(f\" Architecture : BiLSTM(12 → 128, ×3) → FC(256 → {len(SUPERDIAG_CLASSES)})\")\n", + "print(f\" label_key : 'labels' [jtwells2 schema]\")\n", "\n", - "# ── Smoke test: one forward pass ─────────────────────────────────────────────\n", + "# ── Smoke test ────────────────────────────────────────────────────────────────\n", "with torch.no_grad():\n", " test_batch = next(iter(train_loader))\n", " out_s = sparcnet(**test_batch)\n", " out_b = bilstm(**test_batch)\n", "\n", - "print(f\"\\nForward pass smoke test (batch_size={BATCH_SIZE}):\")\n", + "print(f\"\\nForward-pass smoke test (batch_size={BATCH_SIZE}):\")\n", "print(f\" SparcNet logit: {tuple(out_s['logit'].shape)} loss: {out_s['loss'].item():.4f}\")\n", "print(f\" BiLSTMECG logit: {tuple(out_b['logit'].shape)} loss: {out_b['loss'].item():.4f}\")\n", - "print(f\"\\n✅ Both models produce standard PyHealth output dicts.\")\n" + "print(f\"\\n✅ Both models accept 'labels' key and produce standard PyHealth output dicts.\")\n" ] }, { From 38604a62100209adfe9c21ae4b2f5e85555c5005 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Wed, 15 Apr 2026 16:12:01 -0700 Subject: [PATCH 04/10] feature: add BiLSTMECG and SE-ResNet ECG models with pipeline notebooks --- cs598_project/ptbxl_pyhealth_pipeline.ipynb | 5197 ++++++++++++++----- cs598_project/se_resnet_ecg.py | 393 ++ cs598_project/se_resnet_ecg_pipeline.ipynb | 871 ++++ pyhealth/models/__init__.py | 1 + pyhealth/models/bilstm_ecg.py | 192 + 5 files changed, 5425 insertions(+), 1229 deletions(-) create mode 100644 cs598_project/se_resnet_ecg.py create mode 100644 cs598_project/se_resnet_ecg_pipeline.ipynb create mode 100644 pyhealth/models/bilstm_ecg.py diff --git a/cs598_project/ptbxl_pyhealth_pipeline.ipynb b/cs598_project/ptbxl_pyhealth_pipeline.ipynb index e31967755..c2a71e55d 100644 --- a/cs598_project/ptbxl_pyhealth_pipeline.ipynb +++ b/cs598_project/ptbxl_pyhealth_pipeline.ipynb @@ -8,21 +8,21 @@ "# PTB-XL ECG Deep Learning Pipeline\n", "## A Step-by-Step Explanation with Python Code and Flow Diagrams\n", "\n", - "This notebook explains the full pipeline from raw ECG files on disk to a published, reproducible benchmark — the exact pipeline your CS-598 project proposes as a PyHealth contribution.\n", + "This notebook explains the full pipeline from raw ECG files on disk to a published, reproducible benchmark \u2014 the exact pipeline your CS-598 project proposes as a PyHealth contribution.\n", "\n", "```\n", - "Raw PTB-XL files on disk\n", - " ↓ PTBXLDataset.process_EEG_data()\n", - "Structured patient dictionary (18,885 patients × ECG records)\n", - " ↓ dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "SampleDataset (list of windowed samples with multi-hot labels)\n", - " ↓ split_by_patient()\n", + "Raw PTB-XL / CinC 2020 files on disk\n", + " \u2193 PTBXLDataset.process_EEG_data()\n", + "Structured patients dictionary (21,837 recordings, 1 ECG per entry)\n", + " \u2193 dataset.set_task(ptbxl_superdiagnostic_fn)\n", + "SampleDataset (21,666 samples \u2014 full 10s ECG @ 100 Hz, multi-hot labels)\n", + " \u2193 split_by_patient([0.8, 0.1, 0.1], seed=42)\n", "Train / Val / Test splits (no patient leakage)\n", - " ↓ PyHealth Trainer + your model\n", - "Trained DNN (ResNet1d, BiLSTM, Transformer...)\n", - " ↓ trainer.evaluate()\n", - "ROC-AUC macro + F1 macro scores ← reproducible benchmark\n", - " ↓\n", + " \u2193 PyHealth Trainer + your model\n", + "Trained DNN (SparcNet, BiLSTMECG, ...)\n", + " \u2193 trainer.evaluate()\n", + "ROC-AUC macro + F1 macro scores \u2190 reproducible benchmark\n", + " \u2193\n", "Published as a Colab notebook anyone can run\n", "```\n", "\n", @@ -35,12 +35,12 @@ "metadata": {}, "source": [ "---\n", - "## Section 1 — Install and Import Dependencies" + "## Section 1 \u2014 Install and Import Dependencies" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "89ecd1c1", "metadata": {}, "outputs": [ @@ -48,7 +48,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "✅ All imports successful\n", + " All imports successful\n", " PyTorch : 2.8.0\n", " Device : mps\n", " PyHealth: 1.1.6\n" @@ -64,7 +64,7 @@ } ], "source": [ - "# ── Standard library & scientific stack ──────────────────────────────────────\n", + "# \u2500\u2500 Standard library & scientific stack \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "import ast\n", "import os\n", "import pickle\n", @@ -83,21 +83,21 @@ "import torch.nn.functional as F\n", "from sklearn.metrics import roc_auc_score, f1_score\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# PyHealth — the medical-AI framework used throughout this notebook.\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# PyHealth \u2014 the medical-AI framework used throughout this notebook.\n", "#\n", "# Install once with: pip install pyhealth\n", "#\n", "# PyHealth components used:\n", - "# • BaseSignalDataset — abstract base class for signal (ECG/EEG) datasets\n", - "# • SampleSignalDataset — wraps List[Dict] of task samples, handles epoch_path\n", - "# • split_by_patient — patient-level train/val/test split (no leakage)\n", - "# • get_dataloader — converts a SampleSignalDataset subset into a PyTorch DataLoader\n", - "# • SparcNet — DenseNet-based 1D signal classification model\n", - "# • BaseModel — abstract base for building custom PyHealth-compatible models\n", - "# • Trainer — training loop with early stopping + evaluation\n", - "# • multilabel_metrics_fn — computes roc_auc_macro, f1_macro, etc.\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2022 BaseSignalDataset \u2014 abstract base class for signal (ECG/EEG) datasets\n", + "# \u2022 SampleSignalDataset \u2014 wraps List[Dict] of task samples, handles epoch_path\n", + "# \u2022 split_by_patient \u2014 patient-level train/val/test split (no leakage)\n", + "# \u2022 get_dataloader \u2014 converts a SampleSignalDataset subset into a PyTorch DataLoader\n", + "# \u2022 SparcNet \u2014 DenseNet-based 1D signal classification model\n", + "# \u2022 BaseModel \u2014 abstract base for building custom PyHealth-compatible models\n", + "# \u2022 Trainer \u2014 training loop with early stopping + evaluation\n", + "# \u2022 multilabel_metrics_fn \u2014 computes roc_auc_macro, f1_macro, etc.\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "from pyhealth.datasets import (\n", " BaseSignalDataset,\n", " SampleSignalDataset,\n", @@ -110,7 +110,7 @@ "\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning, module=\"dask\")\n", "\n", - "print(\"✅ All imports successful\")\n", + "print(\" All imports successful\")\n", "print(f\" PyTorch : {torch.__version__}\")\n", "print(f\" Device : {'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'}\")\n", "\n", @@ -129,7 +129,7 @@ "metadata": {}, "source": [ "---\n", - "## Section 2 — Full Pipeline Flow Diagram\n", + "## Section 2 \u2014 Full Pipeline Flow Diagram\n", "\n", "Before diving in, look at the entire pipeline end-to-end. \n", "Each box below corresponds to one section of this notebook." @@ -187,21 +187,21 @@ " ax.axis(\"off\")\n", " fig.patch.set_facecolor(\"#0d1117\")\n", "\n", - " # ── Stage definitions ─────────────────────────────────────────────────────\n", + " # \u2500\u2500 Stage definitions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " stages = [\n", " # (y_center, box_color, text_color, icon, title, subtitle, section)\n", - " (14.5, \"#1e3a5f\", \"white\", \"💾\", \"Raw PTB-XL Files on Disk\",\n", - " \"ptbxl_database.csv + 21,837 WFDB signal pairs\\n(.dat / .hea, 500 Hz, 10 s, 12 leads)\", \"§3\"),\n", - " (11.7, \"#1a4731\", \"white\", \"🏗️\", \"PTBXLDataset.process_EEG_data()\",\n", - " \"Groups all ECG records by patient_id\\n→ patients dict: {pid: [record, ...]}\", \"§4–5\"),\n", - " (8.9, \"#4a2f1a\", \"white\", \"🏷️\", \"dataset.set_task(ptbxl_superdiagnostic_fn)\",\n", - " \"Slides 2.5-s windows over each signal\\nMaps scp_codes → 5-class multi-hot label\\nSaves each window as .pkl → SampleDataset\", \"§6–7\"),\n", - " (6.1, \"#3b1f4a\", \"white\", \"✂️\", \"split_by_patient(ratios=[0.8, 0.1, 0.1])\",\n", - " \"Splits entire patients, not individual windows\\n→ zero patient overlap across Train/Val/Test\", \"§8\"),\n", - " (3.5, \"#4a1a1a\", \"white\", \"🧠\", \"PyHealth Trainer × Your DNN Model\",\n", - " \"ResNet1d / BiLSTM / Transformer\\nBCEWithLogitsLoss (multi-label)\\nEarly stop on macro ROC-AUC\", \"§9–10\"),\n", - " (1.0, \"#1a3a3a\", \"#00ffcc\",\"📊\", \"trainer.evaluate() → Metrics\",\n", - " \"ROC-AUC macro + F1 macro\\nPer-class ROC curves\\nReproducible benchmark numbers\", \"§11–12\"),\n", + " (14.5, \"#1e3a5f\", \"white\", \"\ud83d\udcbe\", \"Raw PTB-XL Files on Disk\",\n", + " \"ptbxl_database.csv + 21,837 WFDB signal pairs\\n(.dat / .hea, 500 Hz, 10 s, 12 leads)\", \"\u00a73\"),\n", + " (11.7, \"#1a4731\", \"white\", \"\ud83c\udfd7\ufe0f\", \"PTBXLDataset.process_EEG_data()\",\n", + " \"Groups all ECG records by patient_id\\n\u2192 patients dict: {pid: [record, ...]}\", \"\u00a74\u20135\"),\n", + " (8.9, \"#4a2f1a\", \"white\", \"\ud83c\udff7\ufe0f\", \"dataset.set_task(ptbxl_superdiagnostic_fn)\",\n", + " \"Slides 2.5-s windows over each signal\\nMaps scp_codes \u2192 5-class multi-hot label\\nSaves each window as .pkl \u2192 SampleDataset\", \"\u00a76\u20137\"),\n", + " (6.1, \"#3b1f4a\", \"white\", \"\u2702\ufe0f\", \"split_by_patient(ratios=[0.8, 0.1, 0.1])\",\n", + " \"Splits entire patients, not individual windows\\n\u2192 zero patient overlap across Train/Val/Test\", \"\u00a78\"),\n", + " (3.5, \"#4a1a1a\", \"white\", \"\ud83e\udde0\", \"PyHealth Trainer \u00d7 Your DNN Model\",\n", + " \"ResNet1d / BiLSTM / Transformer\\nBCEWithLogitsLoss (multi-label)\\nEarly stop on macro ROC-AUC\", \"\u00a79\u201310\"),\n", + " (1.0, \"#1a3a3a\", \"#00ffcc\",\"\ud83d\udcca\", \"trainer.evaluate() \u2192 Metrics\",\n", + " \"ROC-AUC macro + F1 macro\\nPer-class ROC curves\\nReproducible benchmark numbers\", \"\u00a711\u201312\"),\n", " ]\n", "\n", " for (y, bg, fg, icon, title, subtitle, section) in stages:\n", @@ -222,7 +222,7 @@ " color=\"#bbbbbb\", fontsize=8.5, va=\"center\", ha=\"left\",\n", " linespacing=1.6, zorder=3)\n", "\n", - " # ── Arrows between boxes ──────────────────────────────────────────────────\n", + " # \u2500\u2500 Arrows between boxes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " arrow_y_pairs = [(13.5, 12.7), (10.7, 9.9), (7.9, 7.1), (5.1, 4.5), (2.5, 2.0)]\n", " for (y1, y2) in arrow_y_pairs:\n", " ax.annotate(\"\", xy=(5.0, y2), xytext=(5.0, y1),\n", @@ -230,7 +230,7 @@ " lw=2.0, mutation_scale=18),\n", " zorder=4)\n", "\n", - " ax.set_title(\"PTB-XL → PyHealth Pipeline — End to End\",\n", + " ax.set_title(\"PTB-XL \u2192 PyHealth Pipeline \u2014 End to End\",\n", " color=\"white\", fontsize=14, fontweight=\"bold\", pad=10)\n", " plt.tight_layout()\n", " plt.show()\n", @@ -244,43 +244,63 @@ "metadata": {}, "source": [ "---\n", - "## Section 3 — Raw PTB-XL Files on Disk\n", + "## Section 3 \u2014 Raw PTB-XL Files on Disk\n", "\n", "### What is PTB-XL?\n", "PTB-XL (Wagner et al., 2020, PhysioNet) is the **largest publicly available clinical 12-lead ECG dataset**:\n", - "- **21,837 recordings** from **18,885 unique patients**\n", - "- Each recording: 10 seconds × 12 leads × 500 Hz = **60,000 samples per recording**\n", + "- **21,837 recordings** from **18,885 unique patients** (paper figures; `ptbxl_database.csv` in this workspace has 21,799 / 18,869 due to minor version differences)\n", + "- Each recording: 10 seconds \u00d7 12 leads \u00d7 500 Hz = **5,000 time-points per lead** (60,000 total scalar values across all 12 leads)\n", "- Labels: physician-annotated SCP codes (e.g. `NORM`, `MI`, `AFIB`) with confidence scores\n", "\n", - "### Directory structure on disk\n", + "### Directory structure on disk (this workspace)\n", + "\n", + "This project uses the **PhysioNet/CinC 2020 Challenge (v1.0.2)** layout, which distributes PTB-XL records as flat MATLAB `.mat` files grouped into 22 sub-folders \u2014 **not** the standard `records100/` / `records500/` WFDB structure of PTB-XL v1.0.1:\n", "\n", "```\n", - "ptb-xl-1.0.1/\n", - "├── ptbxl_database.csv ← metadata for all 21,837 recordings\n", - "├── scp_statements.csv ← lookup: each SCP code → diagnostic class\n", - "├── records100/ ← 100 Hz versions of signals (WFDB format)\n", - "│ ├── 00000/\n", - "│ │ ├── 00001_lr.dat ← raw binary signal data\n", - "│ │ └── 00001_lr.hea ← header: leads, sample rate, calibration\n", - "│ └── ...\n", - "└── records500/ ← 500 Hz versions (used by the paper)\n", - " ├── 00000/\n", - " │ ├── 00001_hr.dat\n", - " │ └── 00001_hr.hea\n", - " └── ...\n", + "training/ptb-xl/ \u2190 PTBXL_CHALLENGE_ROOT\n", + "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", + "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", + "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 signal tensor (12 leads \u00d7 5000 samples @ 500 Hz)\n", + "\u2502 \u251c\u2500\u2500 HR00002.hea\n", + "\u2502 \u251c\u2500\u2500 HR00002.mat\n", + "\u2502 \u2514\u2500\u2500 ...\n", + "\u251c\u2500\u2500 g2/ ... g21/\n", + "\u2514\u2500\u2500 g22/ \u2190 group 22 (838 recordings)\n", + "\n", + "cs598_project/ \u2190 PROJECT_ROOT (Section B only)\n", + "\u251c\u2500\u2500 ptbxl_database.csv \u2190 PTB-XL 1.0.3 metadata (21,799 rows \u00d7 28 cols)\n", + "\u251c\u2500\u2500 scp_statements.csv \u2190 SCP code \u2192 diagnostic class lookup\n", + "\u2514\u2500\u2500 WFDB/\n", + " \u251c\u2500\u2500 HR00001.mat \u2190 same signals, flat layout (500 Hz)\n", + " \u2514\u2500\u2500 HR21837.mat\n", "```\n", "\n", - "### Key columns in `ptbxl_database.csv`\n", + "> The standard PTB-XL v1.0.1 download has `records100/` (100 Hz) and `records500/` (500 Hz) WFDB `.dat`/`.hea` pairs. Those sub-folders are **not present** here \u2014 signals are loaded directly from `.mat` files.\n", + "\n", + "### Key columns in `ptbxl_database.csv` (PTB-XL 1.0.3, used in Section B)\n", + "\n", + "| Column | Meaning |\n", + "|---|---|\n", + "| `ecg_id` | Unique recording ID (1\u201321799) |\n", + "| `patient_id` | Which patient (1\u201318869) \u2014 multiple ECGs per patient possible |\n", + "| `filename_hr` | Relative path to 500 Hz WFDB file |\n", + "| `filename_lr` | Relative path to 100 Hz WFDB file |\n", + "| `scp_codes` | Dict string `{\"SCP_abbreviation\": confidence}` e.g. `\"{'NORM': 100.0}\"` |\n", + "| `strat_fold` | Cross-validation fold (1\u201310); folds 9\u201310 are human-validated |\n", + "| `age`, `sex` | Patient demographics |\n", + "\n", + "### Key columns in `ptbxl-pyhealth.csv` (CinC 2020 format, used in Sections A onward)\n", "\n", "| Column | Meaning |\n", "|---|---|\n", - "| `ecg_id` | Unique recording ID (1–21837) |\n", - "| `patient_id` | Which patient (1–18885) — multiple ECGs per patient |\n", - "| `filename_hr` | Path to 500 Hz WFDB file relative to root |\n", - "| `filename_lr` | Path to 100 Hz WFDB file |\n", - "| `scp_codes` | Dict of `{SCP_code: confidence}` e.g. `{\"NORM\": 100.0}` |\n", - "| `strat_fold` | Cross-validation fold assignment (1–10) |\n", - "| `age`, `sex` | Patient demographics |" + "| `patient_id` | Record stem \u2014 same as `record_id` (e.g. `HR00001`) |\n", + "| `record_id` | Record stem |\n", + "| `signal_file` | Absolute path to `.mat` file |\n", + "| `scp_codes` | SNOMED-CT numeric codes, comma-separated e.g. `\"426783006,251146004\"` |\n", + "| `sampling_rate` | Always 500 |\n", + "| `num_samples` | Always 5000 |\n", + "| `num_leads` | Always 12 |\n", + "| `group` | Parent group folder (`g1`\u2013`g22`) |" ] }, { @@ -293,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "ccc4653b", "metadata": {}, "outputs": [ @@ -302,8 +322,6 @@ "output_type": "stream", "text": [ "Data format : ptbxl_wfdb\n", - "DB CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/ptbxl_database.csv ✅\n", - "WFDB root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/WFDB ✅\n", "ptbxl_database.csv shape : (21799, 27)\n", "Unique patients : 18,869\n", "ECG recordings : 21,799\n", @@ -399,7 +417,7 @@ "text": [ "\n", "Signal file : HR00001.mat\n", - "Raw shape : (12, 5000) → (leads=12, samples=5000 @ 500 Hz)\n", + "Raw shape : (12, 5000) \u2192 (leads=12, samples=5000 @ 500 Hz)\n", "Range (mV) : [-7.220, 3.450]\n", "SCP codes : {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}\n" ] @@ -419,7 +437,7 @@ "output_type": "stream", "text": [ "\n", - "✅ Shape: (12, 5000) (12 leads × 5000 samples @ 500 Hz = 10s)\n" + "\u2705 Shape: (12, 5000) (12 leads \u00d7 5000 samples @ 500 Hz = 10s)\n" ] } ], @@ -431,7 +449,7 @@ "import matplotlib.pyplot as plt\n", "from pathlib import Path\n", "\n", - "# ── Data roots ────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Data roots \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "_PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", "_DB_CSV = _PROJECT_ROOT / \"ptbxl_database.csv\"\n", "_WFDB_ROOT = _PROJECT_ROOT / \"WFDB\"\n", @@ -442,7 +460,7 @@ " / \"training\" / \"ptb-xl\"\n", ")\n", "\n", - "# ── Auto-detect best available format ─────────────────────────────────────────\n", + "# \u2500\u2500 Auto-detect best available format \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "if _DB_CSV.exists() and _WFDB_ROOT.is_dir():\n", " DATA_FORMAT = \"ptbxl_wfdb\" # ptbxl_database.csv + WFDB/ flat .mat files\n", "elif (_PTBXL_CINC / \"ptbxl-pyhealth.csv\").exists():\n", @@ -451,12 +469,10 @@ " DATA_FORMAT = \"synthetic\"\n", "\n", "print(f\"Data format : {DATA_FORMAT}\")\n", - "print(f\"DB CSV : {_DB_CSV} {'✅' if _DB_CSV.exists() else '❌'}\")\n", - "print(f\"WFDB root : {_WFDB_ROOT} {'✅' if _WFDB_ROOT.is_dir() else '❌'}\")\n", "\n", "LEAD_NAMES = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def demo_raw_files(fmt):\n", " if fmt == \"ptbxl_wfdb\":\n", " _demo_ptbxl_wfdb(_DB_CSV, _WFDB_ROOT)\n", @@ -481,20 +497,20 @@ " print(\"First 3 rows (key columns):\")\n", " display(df[[\"patient_id\",\"age\",\"sex\",\"scp_codes\",\"strat_fold\"]].head(3))\n", "\n", - " # Load signal: ecg_id → WFDB/HR{ecg_id:05d}.mat\n", + " # Load signal: ecg_id \u2192 WFDB/HR{ecg_id:05d}.mat\n", " ecg_id = df.index[0] # = 1\n", " mat_path = wfdb_root / f\"HR{ecg_id:05d}.mat\"\n", " data = scipy.io.loadmat(str(mat_path))\n", " signal = data[\"val\"].astype(float) # shape: (12, 5000) channel-first, 500 Hz\n", - " # Convert ADC → mV: gain = 200 ADC units/mV (from .hea file)\n", + " # Convert ADC \u2192 mV: gain = 200 ADC units/mV (from .hea file)\n", " signal_mv = signal / 200.0\n", "\n", " print(f\"\\nSignal file : {mat_path.name}\")\n", - " print(f\"Raw shape : {signal.shape} → (leads=12, samples=5000 @ 500 Hz)\")\n", + " print(f\"Raw shape : {signal.shape} \u2192 (leads=12, samples=5000 @ 500 Hz)\")\n", " print(f\"Range (mV) : [{signal_mv.min():.3f}, {signal_mv.max():.3f}]\")\n", " print(f\"SCP codes : {df.loc[ecg_id, 'scp_codes']}\")\n", " _plot_raw_signal(signal_mv, fs=500,\n", - " title=f\"PTB-XL 1.0.3 (WFDB flat .mat) — ECG #{ecg_id} \"\n", + " title=f\"PTB-XL 1.0.3 (WFDB flat .mat) \u2014 ECG #{ecg_id} \"\n", " f\"Age={int(df.loc[ecg_id,'age'])} \"\n", " f\"{'F' if df.loc[ecg_id,'sex']==1 else 'M'}\")\n", "\n", @@ -508,10 +524,10 @@ "\n", " row = df.iloc[0]\n", " mat = scipy.io.loadmat(str(root / row[\"signal_file\"]))\n", - " signal = mat[\"val\"].astype(float) / 200.0 # ADC → mV\n", + " signal = mat[\"val\"].astype(float) / 200.0 # ADC \u2192 mV\n", " fs = int(row[\"sampling_rate\"])\n", " print(f\"\\nSignal loaded (CinC .mat) : {signal.shape}\")\n", - " _plot_raw_signal(signal, fs, title=\"CinC 2020 PTB-XL — Real 12-lead ECG (500 Hz)\")\n", + " _plot_raw_signal(signal, fs, title=\"CinC 2020 PTB-XL \u2014 Real 12-lead ECG (500 Hz)\")\n", "\n", "\n", "def _show_synthetic_structure():\n", @@ -529,18 +545,18 @@ " \"\"\"signal shape: (12, n_samples).\"\"\"\n", " n = signal.shape[1]\n", " fig, axes = plt.subplots(6, 2, figsize=(14, 9), sharex=True)\n", - " fig.suptitle(f\"{title} — shape {signal.shape} ({fs} Hz × {n//fs} s)\",\n", + " fig.suptitle(f\"{title} \u2014 shape {signal.shape} ({fs} Hz \u00d7 {n//fs} s)\",\n", " fontsize=11, fontweight=\"bold\")\n", " axes_flat = axes.flatten()\n", " for i in range(12):\n", " axes_flat[i].plot(signal[i], linewidth=0.7, color=\"#1f77b4\")\n", " axes_flat[i].set_ylabel(LEAD_NAMES[i], fontsize=8)\n", " axes_flat[i].set_yticks([])\n", - " axes_flat[-1].set_xlabel(f\"Sample index (0–{n} @ {fs} Hz)\")\n", - " axes_flat[-2].set_xlabel(f\"Sample index (0–{n} @ {fs} Hz)\")\n", + " axes_flat[-1].set_xlabel(f\"Sample index (0\u2013{n} @ {fs} Hz)\")\n", + " axes_flat[-2].set_xlabel(f\"Sample index (0\u2013{n} @ {fs} Hz)\")\n", " plt.tight_layout()\n", " plt.show()\n", - " print(f\"\\n✅ Shape: {signal.shape} (12 leads × {n} samples @ {fs} Hz = {n//fs}s)\")\n", + " print(f\"\\n\u2705 Shape: {signal.shape} (12 leads \u00d7 {n} samples @ {fs} Hz = {n//fs}s)\")\n", "\n", "\n", "demo_raw_files(DATA_FORMAT)\n" @@ -551,42 +567,47 @@ "id": "07b055f0", "metadata": {}, "source": [ - "---\n", - "## Section 4 — `PTBXLDataset.process_EEG_data()` — Pipeline Stage 1\n", "\n", "`process_EEG_data()` is the **only abstract method** you must implement when subclassing `BaseSignalDataset`. \n", "Its job is to convert the raw files into a single structured dictionary.\n", "\n", - "### What happens inside it — sub-flow\n", + "### What happens inside it \u2014 sub-flow\n", "\n", "```\n", - "ptbxl_database.csv\n", - " │\n", - " ▼\n", - "Read CSV → parse scp_codes column (string → dict)\n", - " │\n", - " ▼\n", - "For each row: build a record dict with wfdb_path, scp_codes, strat_fold, age, sex\n", - " │\n", - " ▼\n", - "Group records by patient_id (groupby)\n", - " │\n", - " ▼\n", + "ptbxl-pyhealth.csv \u2190 built by prepare_metadata() in this notebook\n", + " \u2502\n", + " \u25bc\n", + "Read CSV \u2192 one row per recording (patient_id == record_id in CinC format)\n", + " \u2502\n", + " \u25bc\n", + "For each row: build a record dict with:\n", + " mat_path (absolute path to .mat signal file)\n", + " scp_codes (SNOMED-CT string, e.g. \"426783006,251146004\")\n", + " age, sex\n", + " \u2502\n", + " \u25bc\n", + "Group records by patient_id\n", + " \u2502\n", + " \u25bc\n", "Return patients = {\n", - " \"1\": [ {ecg_id:\"1\", wfdb_path:\"...\", scp_codes:{...}, strat_fold:9}, ... ],\n", - " \"2\": [ {ecg_id:\"2\", wfdb_path:\"...\", ...} ],\n", + " \"HR00001\": [ {ecg_id:\"HR00001\", mat_path:\"/.../g1/HR00001.mat\",\n", + " scp_codes:\"251146004,426783006\", age:56, sex:\"Female\"} ],\n", + " \"HR00002\": [ {ecg_id:\"HR00002\", mat_path:\"/.../g1/HR00002.mat\",\n", + " scp_codes:\"426177001,426783006\", age:19, sex:\"Male\"} ],\n", " ...\n", - " \"18885\":[ ... ]\n", + " \"HR21837\": [ ... ]\n", "}\n", "```\n", "\n", - "**Key design principle:** `process_EEG_data()` does **NOT** load signal arrays — it only stores file paths. \n", + "> **CinC 2020 format note:** In this dataset each recording is its own patient (`patient_id == record_id`), so no patient has multiple ECGs. There is **no `strat_fold`** column \u2014 train/val/test splits use random patient-level assignment instead (Section 8).\n", + "\n", + "**Key design principle:** `process_EEG_data()` does **NOT** load signal arrays \u2014 it only stores file paths. \n", "Signal loading happens lazily, inside the task function (Section 6), so memory stays low." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "id": "f3bb5d93", "metadata": {}, "outputs": [ @@ -594,12 +615,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] …\n", + "Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] \u2026\n", " CinC root: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", " CSV already present: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", "\n", - "✅ CSV ready: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", - " Shape : (21837, 10) (21,837 records × 10 cols)\n", + " CSV ready: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + " Shape : (21837, 10) (21,837 records \u00d7 10 cols)\n", " Columns : ['patient_id', 'record_id', 'signal_file', 'age', 'sex', 'scp_codes', 'sampling_rate', 'num_samples', 'num_leads', 'group']\n", "\n", "First 3 rows:\n" @@ -703,48 +724,47 @@ "text": [ "\n", "scp_codes example (row 0): '251146004,426783006'\n", - "→ SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\n", + "\u2192 SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\n", "\n", - "Step 4b: Initialising BaseSignalDataset adapter …\n", - "──────────────────────────────────────────────────────────\n", + "Step 4b: Initialising BaseSignalDataset adapter \u2026\n", + "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " PTBXLDataset (jtwells2 :: CinC 2020 format)\n", " Source file : PyHealth/pyhealth/datasets/ptbxl.py\n", " Records : 21,837 (22 group directories)\n", " patient_id : equals record_id (CinC format)\n", " scp_codes : SNOMED-CT numeric strings (binary, no confidence)\n", - " strat_fold : not available → random split\n", - "──────────────────────────────────────────────────────────\n" + " strat_fold : not available \u2192 random split\n", + "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n" ] } ], "source": [ "\n", - "# ── STEP 4: PTBXLDataset — wrapping jtwells2's pyhealth/datasets/ptbxl.py ────\n", + "# \u2500\u2500 STEP 4: PTBXLDataset \u2014 wrapping jtwells2's pyhealth/datasets/ptbxl.py \u2500\u2500\u2500\u2500\n", "#\n", - "# ┌─────────────────────────────────────────────────────────────────────────┐\n", - "# │ SOURCE FILE: PyHealth/pyhealth/datasets/ptbxl.py (jtwells2) │\n", - "# │ CLASS: PTBXLDataset(BaseDataset) │\n", - "# │ KEY METHOD: prepare_metadata() │\n", - "# └─────────────────────────────────────────────────────────────────────────┘\n", + "# \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n", + "# \u2502 SOURCE FILE: PyHealth/pyhealth/datasets/ptbxl.py (jtwells2) \u2502\n", + "# \u2502 CLASS: PTBXLDataset(BaseDataset) \u2502\n", + "# \u2502 KEY METHOD: prepare_metadata() \u2502\n", + "# \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n", "#\n", "# jtwells2's PTBXLDataset.prepare_metadata() scans the CinC 2020 PTB-XL data:\n", "#\n", "# root/\n", - "# g1/ → HR00001.hea + HR00001.mat\n", - "# g2/ → HR01001.hea + HR01001.mat\n", + "# g1/ \u2192 HR00001.hea + HR00001.mat\n", + "# g2/ \u2192 HR01001.hea + HR01001.mat\n", "# ...\n", "# g22/\n", "#\n", "# Each .hea header contains comment lines:\n", "# # Age: 56\n", "# # Sex: Female\n", - "# # Dx: 426783006,251146004 ← SNOMED-CT codes, comma-separated (binary)\n", + "# # Dx: 426783006,251146004 \u2190 SNOMED-CT codes, comma-separated (binary)\n", "#\n", "# It produces ptbxl-pyhealth.csv with columns:\n", "# patient_id | record_id | signal_file | age | sex | scp_codes | ...\n", "#\n", "# KEY DIFFERENCE from PTB-XL v1.0.3 native format:\n", - "# OLD: scp_codes = {\"NORM\": 100.0, \"SR\": 0.0} (SCP abbrevs + confidence %)\n", "# NEW: scp_codes = \"426783006,251146004\" (SNOMED-CT codes, binary)\n", "#\n", "# WHY BaseSignalDataset ADAPTER?\n", @@ -760,11 +780,11 @@ " / \"training\" / \"ptb-xl\"\n", ")\n", "\n", - "# ── Step 4a: prepare_metadata() — exact replication of jtwells2's logic ──────\n", + "# \u2500\u2500 Step 4a: prepare_metadata() \u2014 exact replication of jtwells2's logic \u2500\u2500\u2500\u2500\u2500\u2500\n", "# Source: PyHealth/pyhealth/datasets/ptbxl.py :: PTBXLDataset.prepare_metadata()\n", "def prepare_metadata(root: Path) -> Path:\n", " \"\"\"\n", - " Scan g*/: .hea files → write ptbxl-pyhealth.csv.\n", + " Scan g*/: .hea files \u2192 write ptbxl-pyhealth.csv.\n", " Logic is a direct copy of jtwells2's PTBXLDataset.prepare_metadata().\n", " Adds extra columns (sampling_rate, num_samples, num_leads, group) used\n", " by the Challenge data but not strictly needed for our pipeline.\n", @@ -828,32 +848,32 @@ " return cache_csv\n", "\n", "\n", - "print(\"Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] …\")\n", + "print(\"Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] \u2026\")\n", "print(f\" CinC root: {CINC_PTBXL_ROOT}\")\n", "csv_path = prepare_metadata(CINC_PTBXL_ROOT)\n", "\n", "df_meta = pd.read_csv(csv_path)\n", - "print(f\"\\n✅ CSV ready: {csv_path}\")\n", - "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records × {df_meta.shape[1]} cols)\")\n", + "print(f\"\\n CSV ready: {csv_path}\")\n", + "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records \u00d7 {df_meta.shape[1]} cols)\")\n", "print(f\" Columns : {df_meta.columns.tolist()}\")\n", "print(f\"\\nFirst 3 rows:\")\n", "display(df_meta.head(3))\n", "print(f\"\\nscp_codes example (row 0): '{df_meta['scp_codes'].iloc[0]}'\")\n", - "print(\"→ SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\")\n", + "print(\"\u2192 SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\")\n", "\n", "\n", - "# ── Step 4b: BaseSignalDataset adapter ───────────────────────────────────────\n", + "# \u2500\u2500 Step 4b: BaseSignalDataset adapter \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", "# jtwells2's PTBXLDataset(BaseDataset) uses the LOCAL PyHealth's polars-based\n", "# BaseDataset. The installed pyhealth 1.1.6 has BaseSignalDataset instead.\n", "# We bridge them with a thin adapter with the SAME process_EEG_data() contract.\n", "#\n", "# Schema stored per record (matches jtwells2's CSV columns):\n", - "# patient_id — record stem, e.g. \"HR00001\"\n", - "# ecg_id — same as patient_id (CinC format: each ECG is its own ID)\n", - "# mat_path — absolute path to .mat signal file\n", - "# scp_codes — \"426783006,251146004\" comma-separated SNOMED-CT string\n", - "# age, sex — from .hea header\n", + "# patient_id \u2014 record stem, e.g. \"HR00001\"\n", + "# ecg_id \u2014 same as patient_id (CinC format: each ECG is its own ID)\n", + "# mat_path \u2014 absolute path to .mat signal file\n", + "# scp_codes \u2014 \"426783006,251146004\" comma-separated SNOMED-CT string\n", + "# age, sex \u2014 from .hea header\n", "\n", "class PTBXLDataset(BaseSignalDataset):\n", " \"\"\"\n", @@ -869,7 +889,7 @@ " )\n", "\n", " def process_EEG_data(self) -> dict:\n", - " \"\"\"Parse ptbxl-pyhealth.csv → patients dict expected by BaseSignalDataset.\"\"\"\n", + " \"\"\"Parse ptbxl-pyhealth.csv \u2192 patients dict expected by BaseSignalDataset.\"\"\"\n", " df = pd.read_csv(self._csv_path)\n", " patients = defaultdict(list)\n", " for _, row in df.iterrows():\n", @@ -882,24 +902,24 @@ " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", " \"age\": row.get(\"age\"),\n", " \"sex\": row.get(\"sex\"),\n", - " # No strat_fold in CinC format — splits will be random\n", + " # No strat_fold in CinC format \u2014 splits will be random\n", " })\n", " return dict(patients)\n", "\n", " def stat(self):\n", " total = sum(len(v) for v in self.patients.values())\n", " n_groups = df_meta[\"group\"].nunique() if \"group\" in df_meta.columns else \"?\"\n", - " print(f\"{'─'*58}\")\n", + " print(f\"{'\u2500'*58}\")\n", " print(f\" PTBXLDataset (jtwells2 :: CinC 2020 format)\")\n", " print(f\" Source file : PyHealth/pyhealth/datasets/ptbxl.py\")\n", " print(f\" Records : {total:,} ({n_groups} group directories)\")\n", " print(f\" patient_id : equals record_id (CinC format)\")\n", " print(f\" scp_codes : SNOMED-CT numeric strings (binary, no confidence)\")\n", - " print(f\" strat_fold : not available → random split\")\n", - " print(f\"{'─'*58}\")\n", + " print(f\" strat_fold : not available \u2192 random split\")\n", + " print(f\"{'\u2500'*58}\")\n", "\n", "\n", - "print(\"\\nStep 4b: Initialising BaseSignalDataset adapter …\")\n", + "print(\"\\nStep 4b: Initialising BaseSignalDataset adapter \u2026\")\n", "dataset = PTBXLDataset(csv_path=str(csv_path))\n", "dataset.stat()\n" ] @@ -909,29 +929,46 @@ "id": "0282d6e5", "metadata": {}, "source": [ - "---\n", - "## Section 5 — Inspect the Structured Patient Dictionary\n", "\n", - "After `process_EEG_data()`, we have `dataset.patients` — a plain Python `dict`.\n", + "After `process_EEG_data()`, we have `dataset.patients` \u2014 a plain Python `dict`.\n", "\n", - "```\n", + "```python\n", "dataset.patients = {\n", - " \"1\" : [ {ecg_id:\"1\", wfdb_path:\"...\", scp_codes:{\"NORM\":100.0}, strat_fold:9 , age:52, sex:0},\n", - " {ecg_id:\"12\", wfdb_path:\"...\", scp_codes:{\"NORM\":90.0}, strat_fold:9 , age:52, sex:0} ],\n", - " \"2\" : [ {ecg_id:\"3\", wfdb_path:\"...\", scp_codes:{\"MI\":80.0,\"ISCAL\":20.0}, strat_fold:7, ...} ],\n", + " \"HR00001\": [ {\n", + " \"patient_id\": \"HR00001\",\n", + " \"ecg_id\": \"HR00001\",\n", + " \"mat_path\": \"/.../g1/HR00001.mat\",\n", + " \"scp_codes\": \"251146004,426783006\", # SNOMED-CT codes, comma-separated string\n", + " \"age\": 56,\n", + " \"sex\": \"Female\"\n", + " } ],\n", + " \"HR00002\": [ {\n", + " \"patient_id\": \"HR00002\",\n", + " \"ecg_id\": \"HR00002\",\n", + " \"mat_path\": \"/.../g1/HR00002.mat\",\n", + " \"scp_codes\": \"426177001,426783006\",\n", + " \"age\": 19,\n", + " \"sex\": \"Male\"\n", + " } ],\n", " ...\n", - " \"18885\" : [ ... ]\n", + " \"HR21837\": [ ... ]\n", "}\n", "```\n", "\n", + "> **Key differences from PTB-XL v1.0.3:**\n", + "> - `patient_id == record_id` (CinC 2020 assigns one ID per recording, not per person)\n", + "> - `scp_codes` is a **comma-separated SNOMED-CT numeric string** \u2014 not a dict with confidence scores\n", + "> - No `strat_fold` field \u2014 not available in CinC format\n", + "> - One record per patient (list always has length 1 in this dataset)\n", + "\n", "**Why group by patient?** \n", - "Because when we later split into Train/Val/Test, we split **at the patient level** — \n", - "all ECGs from one patient stay together in the same split, preventing data leakage." + "`split_by_patient()` splits the `patients` dict first, then gathers all samples for each group. \n", + "Even though each patient here has exactly one ECG, splitting by `patient_id` rather than by sample index is the correct, leak-proof pattern \u2014 and it keeps the code identical to Section B which does have multiple ECGs per patient." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "id": "d2854a79", "metadata": {}, "outputs": [ @@ -954,7 +991,7 @@ " sex : 'Female'\n", "\n", "Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\n", - " (comma-separated binary codes — no confidence % field)\n" + " (comma-separated binary codes \u2014 no confidence % field)\n" ] }, { @@ -976,32 +1013,32 @@ "Total code occurrences : 56,129\n", "\n", "Top 10 most common codes:\n", - " 426783006 × 18,092\n", - " 164865005 × 5,261\n", - " 39732003 × 5,146\n", - " 164951009 × 3,389\n", - " 164873001 × 2,359\n", - " 164934002 × 2,345\n", - " 164861001 × 2,175\n", - " 445118002 × 1,626\n", - " 164889003 × 1,514\n", - " 164884008 × 1,154\n", - "\n", - "✅ dataset.patients built. No signals loaded yet — only metadata + file paths.\n" + " 426783006 \u00d7 18,092\n", + " 164865005 \u00d7 5,261\n", + " 39732003 \u00d7 5,146\n", + " 164951009 \u00d7 3,389\n", + " 164873001 \u00d7 2,359\n", + " 164934002 \u00d7 2,345\n", + " 164861001 \u00d7 2,175\n", + " 445118002 \u00d7 1,626\n", + " 164889003 \u00d7 1,514\n", + " 164884008 \u00d7 1,154\n", + "\n", + "\u2705 dataset.patients built. No signals loaded yet \u2014 only metadata + file paths.\n" ] } ], "source": [ "\n", - "# ── STEP 5: Inspect the patients dictionary (CinC 2020 format) ───────────────\n", + "# \u2500\u2500 STEP 5: Inspect the patients dictionary (CinC 2020 format) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", "# In PTB-XL v1.0.3 native format: patients dict had 18,869 REAL patient IDs\n", - "# → multiple ECGs per patient, strat_fold 1-10 for guaranteed splits\n", + "# multiple ECGs per patient, strat_fold 1-10 for guaranteed splits\n", "#\n", "# In CinC 2020 format (jtwells2 :: PTBXLDataset):\n", - "# → patient_id == record_id == \"HR00001\" (no true patient ID in .hea files)\n", - "# → every ECG is its own \"patient\" → exactly 1 record per patient-ID\n", - "# → no strat_fold → splits are random by recording\n", + "# patient_id == record_id == \"HR00001\" (no true patient ID in .hea files)\n", + "# every ECG is its own \"patient\" \u2192 exactly 1 record per patient-ID\n", + "# no strat_fold \u2192 splits are random by recording\n", "#\n", "# This is a fundamental design decision in jtwells2's file: the Challenge 2020\n", "# PTB-XL headers do NOT include a shared patient identifier, so the class\n", @@ -1021,9 +1058,9 @@ "\n", "print()\n", "print(\"Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\")\n", - "print(\" (comma-separated binary codes — no confidence % field)\")\n", + "print(\" (comma-separated binary codes \u2014 no confidence % field)\")\n", "\n", - "# ── Distribution plots ────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Distribution plots \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "ecg_counts = [len(v) for v in dataset.patients.values()]\n", "\n", "# Count SNOMED codes per recording\n", @@ -1059,7 +1096,7 @@ "plt.tight_layout()\n", "plt.show()\n", "\n", - "# ── Code vocabulary ───────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Code vocabulary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "all_codes = []\n", "for recs in dataset.patients.values():\n", " for r in recs:\n", @@ -1070,8 +1107,8 @@ "print(f\"\\nTop 10 most common codes:\")\n", "top10 = Counter(all_codes).most_common(10)\n", "for code, cnt in top10:\n", - " print(f\" {code} × {cnt:,}\")\n", - "print(\"\\n✅ dataset.patients built. No signals loaded yet — only metadata + file paths.\")\n" + " print(f\" {code} \u00d7 {cnt:,}\")\n", + "print(\"\\n\u2705 dataset.patients built. No signals loaded yet \u2014 only metadata + file paths.\")\n" ] }, { @@ -1079,19 +1116,19 @@ "id": "575df087", "metadata": {}, "source": [ - "---\n", - "## Section 6 — Apply the Superdiagnostic Task (`dataset.set_task(...)`)\n", "\n", "### What is a Task function?\n", "\n", "A **task function** is a plain Python function that:\n", "\n", "1. Receives **one patient's records** (the list from `dataset.patients[pid]`)\n", - "2. Loads the actual signal array from disk for each record\n", - "3. Applies a **sliding window** to break the 10-second recording into sub-windows\n", - "4. Converts `scp_codes` dict into a **multi-hot label vector**\n", - "5. Saves each window as a `.pkl` file (avoids re-loading on every epoch)\n", - "6. Returns a `List[Dict]` — one dict per window = one training sample\n", + "2. Loads the actual signal array from disk for each record via `scipy.io.loadmat()`\n", + "3. Decimates from native 500 Hz to 100 Hz: `signal[:, ::5]` \u2192 shape `(12, 1000)`\n", + "4. Converts SNOMED-CT `scp_codes` string into a **list of superdiagnostic class names**\n", + "5. Caches each sample as a `.pkl` file (loaded lazily per batch by `SampleSignalDataset`)\n", + "6. Returns a `List[Dict]` \u2014 **one dict per recording** = one training sample\n", + "\n", + "> **No sliding windows in this implementation.** The full 10-second recording is used as a single sample after decimation. Previous notebook versions used 2.5-second sliding windows at 500 Hz; the current version follows jtwells2's `PTBXLMultilabelClassification` which keeps the full waveform decimated to 100 Hz.\n", "\n", "### The 5 superdiagnostic classes\n", "\n", @@ -1099,50 +1136,66 @@ "\n", "| Index | Class | Meaning |\n", "|---|---|---|\n", - "| 0 | `NORM` | Normal ECG |\n", - "| 1 | `CD` | Conduction Disturbance |\n", - "| 2 | `HYP` | Hypertrophy |\n", - "| 3 | `MI` | Myocardial Infarction |\n", - "| 4 | `STTC` | ST/T-change (ischemia signs) |\n", + "| 0 | `NORM` | Normal sinus rhythm |\n", + "| 1 | `MI` | Myocardial Infarction |\n", + "| 2 | `STTC` | ST/T-change (ischemia signs) |\n", + "| 3 | `CD` | Conduction Disturbance |\n", + "| 4 | `HYP` | Hypertrophy |\n", "\n", - "A recording can have **multiple active classes simultaneously** — this is multi-label classification. \n", - "The label vector `[1, 0, 0, 1, 0]` means \"NORM and MI are both present.\"\n", + "A recording can have **multiple active classes simultaneously** \u2014 this is multi-label classification. \n", + "The label list `[\"NORM\", \"MI\"]` means \"Normal sinus rhythm and Myocardial Infarction are both present.\"\n", "\n", "### Flow inside `set_task()`:\n", "\n", "```\n", "dataset.patients\n", - " │\n", - " ╔═══════════════════════════════════════╗\n", - " ║ for each patient (18,885 patients): ║\n", - " ║ for each ECG record of that patient║\n", - " ║ 1. wfdb.rdsamp(wfdb_path) ║\n", - " ║ → signal (5000, 12) ║\n", - " ║ 2. scp_codes → 5-class label ║\n", - " ║ 3. Slide window (stride = 625) ║\n", - " ║ window 0: samples [0:1250] ║\n", - " ║ window 1: samples [625:1875] ║\n", - " ║ window 2: samples [1250:2500] ║\n", - " ║ window 3: samples [1875:3125] ║\n", - " ║ window 4: samples [2500:3750] ║\n", - " ║ window 5: samples [3125:4375] ║\n", - " ║ window 6: samples [3750:5000] ║\n", - " ║ 4. pickle.dump each window ║\n", - " ║ 5. append sample dict to list ║\n", - " ╚═══════════════════════════════════════╝\n", - " │\n", - " ▼\n", + " \u2502\n", + " \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n", + " \u2551 for each patient (21,837 entries, 1 ECG each): \u2551\n", + " \u2551 \u2551\n", + " \u2551 1. scipy.io.loadmat(mat_path) \u2551\n", + " \u2551 \u2192 mat[\"val\"] shape (12, 5000) @ 500 Hz \u2551\n", + " \u2551 \u2192 /200.0 (ADC \u2192 millivolts) \u2551\n", + " \u2551 \u2551\n", + " \u2551 2. Decimate: signal[:, ::5] \u2551\n", + " \u2551 \u2192 shape (12, 1000) @ 100 Hz \u2551\n", + " \u2551 \u2551\n", + " \u2551 3. Parse SNOMED-CT codes \u2192 superdiagnostic labels \u2551\n", + " \u2551 \"426783006,251146004\" \u2192 [\"NORM\", \"HYP\"] \u2551\n", + " \u2551 (uses SNOMED_TO_SUPERDIAG: 46-code map) \u2551\n", + " \u2551 \u2551\n", + " \u2551 4. pickle.dump \u2192 cache/{ecg_id}.pkl \u2551\n", + " \u2551 5. Append sample dict to list \u2551\n", + " \u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\n", + " \u2502\n", + " \u25bc\n", "SampleDataset.samples = [\n", - " {patient_id:\"1\", ecg_id:\"1\", epoch_path:\"~/.cache/.../1-1-0.pkl\", label:[1,0,0,0,0]},\n", - " {patient_id:\"1\", ecg_id:\"1\", epoch_path:\"~/.cache/.../1-1-1.pkl\", label:[1,0,0,0,0]},\n", - " ... ← ~7 windows per ECG × 21,837 ECGs ≈ 152,859 total samples\n", + " {patient_id:\"HR00001\", ecg_id:\"HR00001\",\n", + " epoch_path:\"~/.cache/pyhealth_ptbxl/cinc_100hz/HR00001.pkl\",\n", + " \"labels\": [\"NORM\", \"HYP\"]}, \u2190 \"labels\" key (jtwells2 schema, plural)\n", + " {patient_id:\"HR00002\", ecg_id:\"HR00002\",\n", + " epoch_path:\"~/.cache/pyhealth_ptbxl/cinc_100hz/HR00002.pkl\",\n", + " \"labels\": [\"NORM\"]},\n", + " ... \u2190 ~21,666 samples total (171 skipped \u2014 no mappable diagnosis)\n", "]\n", - "```" + "```\n", + "\n", + "### SNOMED_TO_SUPERDIAG \u2014 the 46-code mapping\n", + "\n", + "Source: `jtwells2/PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py`\n", + "\n", + "| Class | SNOMED codes mapped | Count |\n", + "|---|---|---|\n", + "| `NORM` | 426783006 | 1 |\n", + "| `MI` | 57054005, 164865005, 413444003, 413867000, 164861001, 164857002, 164860000, 164864009, 164867002 | 9 |\n", + "| `STTC` | 164931005, 164934002, 59931005, 164947007, 164917005, 251268003, 428750005 | 7 |\n", + "| `CD` | 270492004, 195042002, 27885002, 6374002, 713427006, 713426002, 164909002, 59118001, 698252002, 445118002, 10370003, 164889003, 164890007, 426627000, 427393009, 426177001, 427084000, 63593006, 17338001, 284470004, 427172004 | 21 |\n", + "| `HYP` | 55827005, 446358003, 73282002, 67751000119106, 446813000, 39732003, 47665007, 251146004 | 8 |" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "7d06120b", "metadata": {}, "outputs": [ @@ -1150,51 +1203,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\n", - "(SNOMED-CT codes from CinC .hea files — binary labels, no threshold)\n", + "Calling dataset.set_task(ptbxl_superdiagnostic_fn) \u2026\n", + " Signal : full 10-second ECG, decimated 500\u2192100 Hz \u2192 (12, 1000)\n", + " Labels : 'labels' key [jtwells2 schema]\n", + " Mapping : SNOMED_TO_SUPERDIAG from ptbxl_multilabel_classification.py\n", "\n", - "INFO: Pandarallel will run on 10 workers.\n", - "INFO: Pandarallel will use standard multiprocessing data transfer (pipe) to transfer data between the main process and workers.\n", + "SampleSignalDataset: 21,767 samples (one per recording, no sliding windows)\n", + " input_info: {'signal': {'length': 1000, 'n_channels': 12}, 'label': {'type': , 'dim': 0}, 'labels': {'type': , 'dim': 2}}\n", "\n", - "SampleSignalDataset: 152,859 samples\n", - " input_info: {'signal': {'length': 1250, 'n_channels': 12}, 'label': {'type': , 'dim': 2}}\n", + "Label prevalence (jtwells2 SNOMED_TO_SUPERDIAG):\n", + " NORM 83.1% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " MI 30.5% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " STTC 15.9% \u2588\u2588\u2588\u2588\n", + " CD 37.7% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " HYP 26.2% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", "\n", - "Label prevalence (binary SNOMED-CT mapping):\n", - " NORM 86.9% ██████████████████████████\n", - " CD 50.0% ██████████████\n", - " HYP 29.2% ████████\n", - " MI 3.9% █\n", - " STTC 29.4% ████████\n" + "Sample dict keys : ['patient_id', 'record_id', 'ecg_id', 'epoch_path', 'labels']\n", + " epoch_path : ...he/pyhealth_ptbxl/cinc_100hz/HR00001.pkl\n", + " labels : ['HYP', 'NORM']\n" ] } ], "source": [ "\n", - "# ── STEP 6: Task Function — aligned with jtwells2's PTBXLMultilabelClassification\n", + "# \u2500\u2500 STEP 6: Task Function \u2014 aligned with jtwells2's PTBXLMultilabelClassification\n", "#\n", - "# ┌──────────────────────────────────────────────────────────────────────────┐\n", - "# │ SOURCE FILE: PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py │\n", - "# │ CLASS: PTBXLMultilabelClassification(BaseTask) │\n", - "# │ AUTHOR: jtwells2 (CS-598 DLH Team) │\n", - "# └──────────────────────────────────────────────────────────────────────────┘\n", + "# \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n", + "# \u2502 SOURCE FILE: PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py \u2502\n", + "# \u2502 CLASS: PTBXLMultilabelClassification(BaseTask) \u2502\n", + "# \u2502 AUTHOR: jtwells2 (CS-598 DLH Team) \u2502\n", + "# \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n", "#\n", "# jtwells2's __call__(patient) does exactly:\n", "# 1. Load .mat signal (12, 5000) at 500 Hz\n", - "# 2. Decimate to 100 Hz: signal[:, ::5] → shape (12, 1000)\n", + "# 2. Decimate to 100 Hz: signal[:, ::5] \u2192 shape (12, 1000)\n", "# OR keep 500 Hz: shape (12, 5000)\n", "# 3. Parse SNOMED-CT codes from scp_codes attribute\n", - "# 4. Map codes → NORM / MI / STTC / CD / HYP via SNOMED_TO_SUPERDIAG\n", + "# 4. Map codes \u2192 NORM / MI / STTC / CD / HYP via SNOMED_TO_SUPERDIAG\n", "# 5. Return [{\"signal\": np.ndarray, \"labels\": List[str]}] (ONE per recording)\n", "#\n", "# KEY DIFFERENCES from our previous custom task function:\n", "#\n", "# OLD (custom task) NEW (jtwells2 aligned)\n", - "# ───────────────────────────── ──────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Sliding 2.5s windows @ 500Hz Full 10s recording, decimated to 100Hz\n", - "# ~7 windows per ECG → ~152k 1 sample per recording → ~19k samples\n", + "# ~7 windows per ECG \u2192 ~152k 1 sample per recording \u2192 ~19k samples\n", "# \"label\" key (singular) \"labels\" key (plural, jtwells2 schema)\n", "# 50-code hand-built SNOMED map jtwells2's 46-code clinically correct map\n", - "# confidence threshold none binary (same — CinC codes are all +ve)\n", + "# confidence threshold none binary (same \u2014 CinC codes are all +ve)\n", "# NORM mapped too broadly NORM = only 426783006 (correct NSR code)\n", "#\n", "# WHY epoch_path AND NOT direct signal array?\n", @@ -1204,14 +1260,14 @@ "\n", "from scipy.io import loadmat as scipy_loadmat\n", "\n", - "# ── SNOMED_TO_SUPERDIAG dict ──────────────────────────────────────────────────\n", + "# \u2500\u2500 SNOMED_TO_SUPERDIAG dict \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Direct copy from jtwells2's ptbxl_multilabel_classification.py\n", "# Clinically correct mapping from Table 1 of Strodthoff et al. (2020)\n", "SNOMED_TO_SUPERDIAG = {\n", - " # ── NORM: Normal sinus rhythm only ──────────────────────────────────── #\n", + " # \u2500\u2500 NORM: Normal sinus rhythm only \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", " \"426783006\": \"NORM\", # Normal sinus rhythm\n", "\n", - " # ── MI: Myocardial Infarction ────────────────────────────────────────── #\n", + " # \u2500\u2500 MI: Myocardial Infarction \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", " \"57054005\": \"MI\", # Acute myocardial infarction\n", " \"164865005\": \"MI\", # Myocardial infarction (generic)\n", " \"413444003\": \"MI\", # Acute MI of anterolateral wall\n", @@ -1222,7 +1278,7 @@ " \"164864009\": \"MI\", # Posterior MI\n", " \"164867002\": \"MI\", # Lateral MI\n", "\n", - " # ── STTC: ST/T-wave Change ───────────────────────────────────────────── #\n", + " # \u2500\u2500 STTC: ST/T-wave Change \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", " \"164931005\": \"STTC\", # ST elevation\n", " \"164934002\": \"STTC\", # ST depression\n", " \"59931005\": \"STTC\", # T-wave abnormality / inverted T-wave\n", @@ -1231,7 +1287,7 @@ " \"251268003\": \"STTC\", # Early repolarisation pattern\n", " \"428750005\": \"STTC\", # Non-specific ST-T change\n", "\n", - " # ── CD: Conduction Disturbance / Rhythm Disorder ─────────────────────── #\n", + " # \u2500\u2500 CD: Conduction Disturbance / Rhythm Disorder \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", " \"270492004\": \"CD\", # First-degree AV block\n", " \"195042002\": \"CD\", # Second-degree AV block\n", " \"27885002\": \"CD\", # Third-degree AV block (complete heart block)\n", @@ -1254,7 +1310,7 @@ " \"284470004\": \"CD\", # Premature atrial contraction\n", " \"427172004\": \"CD\", # Premature ventricular contraction\n", "\n", - " # ── HYP: Hypertrophy / Axis Deviation ───────────────────────────────── #\n", + " # \u2500\u2500 HYP: Hypertrophy / Axis Deviation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", " \"55827005\": \"HYP\", # Left ventricular hypertrophy\n", " \"446358003\": \"HYP\", # Right ventricular hypertrophy\n", " \"73282002\": \"HYP\", # Biventricular hypertrophy\n", @@ -1265,11 +1321,11 @@ " \"251146004\": \"HYP\", # Low QRS voltage\n", "}\n", "\n", - "# Ordered class list — from jtwells2's SUPERDIAG_CLASSES\n", + "# Ordered class list \u2014 from jtwells2's SUPERDIAG_CLASSES\n", "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", "\n", "\n", - "# ── Task function — mirrors PTBXLMultilabelClassification.__call__() ──────────\n", + "# \u2500\u2500 Task function \u2014 mirrors PTBXLMultilabelClassification.__call__() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def ptbxl_superdiagnostic_fn(\n", " record_list: list,\n", " sampling_rate: int = 100, # jtwells2 default\n", @@ -1278,10 +1334,10 @@ " \"\"\"\n", " Task function aligned with jtwells2's PTBXLMultilabelClassification.__call__().\n", "\n", - " SIGNAL: full 10-second ECG decimated to 100 Hz → shape (12, 1000)\n", + " SIGNAL: full 10-second ECG decimated to 100 Hz \u2192 shape (12, 1000)\n", " Matches jtwells2: signal = mat[\"val\"] ; signal[:, ::5]\n", "\n", - " LABELS: \"labels\" key (plural) → List[str] of superdiagnostic class names\n", + " LABELS: \"labels\" key (plural) \u2192 List[str] of superdiagnostic class names\n", " Matches jtwells2 output schema: {\"signal\": ..., \"labels\": [...]}\n", "\n", " STORAGE: cached as .pkl files (epoch_path key) for installed pyhealth\n", @@ -1298,29 +1354,29 @@ " ecg_id = visit[\"ecg_id\"]\n", " mat_path = visit[\"mat_path\"]\n", "\n", - " # ── 1. Parse SNOMED-CT codes → superdiagnostic labels ─────────────\n", + " # \u2500\u2500 1. Parse SNOMED-CT codes \u2192 superdiagnostic labels \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " raw = str(visit[\"scp_codes\"])\n", " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", " if not labels:\n", " continue # skip recordings with no mappable diagnosis\n", "\n", - " # ── 2. Load signal (mirrors jtwells2's scipy.io.loadmat(signal_file)) ─\n", + " # \u2500\u2500 2. Load signal (mirrors jtwells2's scipy.io.loadmat(signal_file)) \u2500\n", " if mat_path and Path(mat_path).exists():\n", " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC → mV, (12, 5000)\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC \u2192 mV, (12, 5000)\n", " else:\n", " t = np.linspace(0, 10, native_freq * 10)\n", " lead = 0.5*np.sin(2*np.pi*1.2*t) + np.random.randn(native_freq*10)*0.04\n", " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", "\n", - " # ── 3. Decimate to target sampling rate (mirrors jtwells2: signal[:, ::5])\n", - " signal = signal[:, ::decimate] # → (12, 1000)\n", + " # \u2500\u2500 3. Decimate to target sampling rate (mirrors jtwells2: signal[:, ::5])\n", + " signal = signal[:, ::decimate] # \u2192 (12, 1000)\n", "\n", " if signal.shape[1] < expected_len:\n", - " continue # malformed recording — skip\n", + " continue # malformed recording \u2014 skip\n", "\n", - " # ── 4. Cache as .pkl — required by installed pyhealth SampleSignalDataset\n", + " # \u2500\u2500 4. Cache as .pkl \u2014 required by installed pyhealth SampleSignalDataset\n", " pkl_path = str(cache_dir / f\"{ecg_id}.pkl\")\n", " if not Path(pkl_path).exists(): # skip if already cached\n", " with open(pkl_path, \"wb\") as f:\n", @@ -1331,14 +1387,14 @@ " \"record_id\": ecg_id,\n", " \"ecg_id\": ecg_id,\n", " \"epoch_path\": pkl_path, # installed SampleSignalDataset requirement\n", - " \"labels\": labels, # \"labels\" key — jtwells2 schema\n", + " \"labels\": labels, # \"labels\" key \u2014 jtwells2 schema\n", " })\n", " return samples\n", "\n", "\n", - "# ── Apply task ────────────────────────────────────────────────────────────────\n", - "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) …\")\n", - "print(\" Signal : full 10-second ECG, decimated 500→100 Hz → (12, 1000)\")\n", + "# \u2500\u2500 Apply task \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) \u2026\")\n", + "print(\" Signal : full 10-second ECG, decimated 500\u2192100 Hz \u2192 (12, 1000)\")\n", "print(\" Labels : 'labels' key [jtwells2 schema]\")\n", "print(\" Mapping : SNOMED_TO_SUPERDIAG from ptbxl_multilabel_classification.py\\n\")\n", "\n", @@ -1357,15 +1413,14 @@ "print(f\" input_info: {sample_dataset.input_info}\")\n", "print(f\"\\nLabel prevalence (jtwells2 SNOMED_TO_SUPERDIAG):\")\n", "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", - " bar = \"█\" * int(rate * 30)\n", + " bar = \"\u2588\" * int(rate * 30)\n", " print(f\" {cls:<6} {rate*100:5.1f}% {bar}\")\n", "\n", "# Verify schema matches jtwells2's PTBXLMultilabelClassification output\n", "sample0 = sample_dataset.samples[0]\n", "print(f\"\\nSample dict keys : {list(sample0.keys())}\")\n", "print(f\" epoch_path : ...{sample0['epoch_path'][-40:]}\")\n", - "print(f\" labels : {sample0['labels']}\")\n", - "print(f\"\\n✅ Task applied. Schema: epoch_path + 'labels' (jtwells2 / PTBXLMultilabelClassification)\")\n" + "print(f\" labels : {sample0['labels']}\")\n" ] }, { @@ -1374,7 +1429,7 @@ "metadata": {}, "source": [ "---\n", - "## Section 7 — Visualize a Sample Window and its Multi-hot Label" + "## Section 7 \u2014 Visualize a Sample Window and its Multi-hot Label" ] }, { @@ -1385,7 +1440,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1397,19 +1452,22 @@ "name": "stdout", "output_type": "stream", "text": [ + " signal shape : (12, 1000) (12 leads \u00d7 1000 samples @ 100 Hz = 10 s)\n", + " labels : ['HYP', 'NORM']\n", + " multi-hot : [1.0, 0.0, 0.0, 0.0, 1.0] [NORM, MI, STTC, CD, HYP]\n", + " SNOMED-CT Dx : 251146004,426783006\n", "\n", - " signal shape : (12, 1250) (12 leads × 1250 samples @ 500 Hz = 2.5 s)\n", - " label : ['NORM'] → multi-hot: [1.0, 0.0, 0.0, 0.0, 0.0]\n" + " Schema key 'labels' (plural) matches jtwells2 :: PTBXLMultilabelClassification\n" ] } ], "source": [ "\n", - "# ── STEP 7: Visualize a sample window and its multi-hot label ─────────────────\n", + "# \u2500\u2500 STEP 7: Visualize a sample window and its multi-hot label \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", "# Schema after jtwells2 alignment:\n", - "# sample[\"epoch_path\"] → .pkl file with {\"signal\": np.float32(12, 1000)}\n", - "# sample[\"labels\"] → List[str] e.g. [\"NORM\"] or [\"CD\", \"MI\"]\n", + "# sample[\"epoch_path\"] .pkl file with {\"signal\": np.float32(12, 1000)}\n", + "# sample[\"labels\"] List[str] e.g. [\"NORM\"] or [\"CD\", \"MI\"]\n", "# (key is \"labels\", NOT \"label\")\n", "#\n", "# Signal shape is now (12, 1000) at 100 Hz (full 10-second recording),\n", @@ -1418,25 +1476,25 @@ "\n", "def visualize_sample(sample: dict):\n", " \"\"\"Plot the 12-lead ECG and multi-hot label bar for one sample.\"\"\"\n", - " # ── Load signal from epoch_path pickle ────────────────────────────────\n", + " # \u2500\u2500 Load signal from epoch_path pickle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " with open(sample[\"epoch_path\"], \"rb\") as f:\n", " data = pickle.load(f)\n", "\n", " signal = data[\"signal\"] # (12, 1000) float32 @ 100 Hz\n", - " label_list = sample[\"labels\"] # ← \"labels\" key (jtwells2 schema)\n", + " label_list = sample[\"labels\"] # \u2190 \"labels\" key (jtwells2 schema)\n", "\n", - " # Convert List[str] → multi-hot for the bar chart\n", + " # Convert List[str] \u2192 multi-hot for the bar chart\n", " label_vec = [1.0 if cls in label_list else 0.0 for cls in SUPERDIAG_CLASSES]\n", "\n", " fig = plt.figure(figsize=(15, 9))\n", " gs = gridspec.GridSpec(2, 1, figure=fig, height_ratios=[4, 1], hspace=0.4)\n", "\n", - " # ── Top: 12-lead ECG ──────────────────────────────────────────────────\n", + " # \u2500\u2500 Top: 12-lead ECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " gs_top = gridspec.GridSpecFromSubplotSpec(6, 2, subplot_spec=gs[0],\n", " hspace=0.05, wspace=0.3)\n", " lead_names = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", " fs = 100 # jtwells2: 100 Hz\n", - " t_axis = np.arange(signal.shape[1]) / fs # 0 … 10 seconds\n", + " t_axis = np.arange(signal.shape[1]) / fs # 0 \u2026 10 seconds\n", "\n", " for i in range(12):\n", " row, col = divmod(i, 2)\n", @@ -1453,12 +1511,12 @@ " patient_scp = dataset.patients[sample[\"patient_id\"]][0][\"scp_codes\"]\n", " fig.text(\n", " 0.5, 0.97,\n", - " f\"Full 10-second ECG @ 100 Hz — patient {sample['patient_id']} \"\n", - " f\"| shape: {signal.shape} (12 leads × 1000 samples)\",\n", + " f\"Full 10-second ECG @ 100 Hz \u2014 patient {sample['patient_id']} \"\n", + " f\"| shape: {signal.shape} (12 leads \u00d7 1000 samples)\",\n", " ha=\"center\", fontsize=11, fontweight=\"bold\",\n", " )\n", "\n", - " # ── Bottom: multi-hot label bar ───────────────────────────────────────\n", + " # \u2500\u2500 Bottom: multi-hot label bar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " ax_lbl = fig.add_subplot(gs[1])\n", " colors = [\"#2ecc71\" if v else \"#e74c3c\" for v in label_vec]\n", " bars = ax_lbl.bar(SUPERDIAG_CLASSES, label_vec,\n", @@ -1466,7 +1524,7 @@ " for bar_, val in zip(bars, label_vec):\n", " ax_lbl.text(\n", " bar_.get_x() + bar_.get_width() / 2, val + 0.03,\n", - " \"✓ ACTIVE\" if val else \"✗ absent\",\n", + " \"\u2713 ACTIVE\" if val else \"\u2717 absent\",\n", " ha=\"center\", va=\"bottom\", fontsize=9,\n", " color=\"#2ecc71\" if val else \"#aaaaaa\",\n", " )\n", @@ -1485,7 +1543,7 @@ " plt.show()\n", "\n", " # Summary\n", - " print(f\" signal shape : {signal.shape} (12 leads × 1000 samples @ 100 Hz = 10 s)\")\n", + " print(f\" signal shape : {signal.shape} (12 leads \u00d7 1000 samples @ 100 Hz = 10 s)\")\n", " print(f\" labels : {label_list}\")\n", " print(f\" multi-hot : {label_vec} [{', '.join(SUPERDIAG_CLASSES)}]\")\n", " print(f\" SNOMED-CT Dx : {patient_scp}\")\n", @@ -1501,32 +1559,32 @@ "metadata": {}, "source": [ "---\n", - "## Section 8 — Split Dataset by Patient (Train / Val / Test)\n", + "## Section 8 \u2014 Split Dataset by Patient (Train / Val / Test)\n", "\n", "### Why split by Patient, not by Sample?\n", "\n", "If you split randomly by sample, windows from the **same patient** can appear in both \n", "train and test. The model memorizes the patient's signal rather than learning the disease. \n", - "This is **data leakage** — test accuracy looks high but won't generalize.\n", + "This is **data leakage** \u2014 test accuracy looks high but won't generalize.\n", "\n", "**The correct approach:** split the `patients` dict first, then gather all samples from each group.\n", "\n", "```\n", "All 18,885 patients\n", - " ├── Train patients (80%) → all their windows → Train split\n", - " ├── Val patients (10%) → all their windows → Val split\n", - " └── Test patients (10%) → all their windows → Test split\n", + " \u251c\u2500\u2500 Train patients (80%) \u2192 all their windows \u2192 Train split\n", + " \u251c\u2500\u2500 Val patients (10%) \u2192 all their windows \u2192 Val split\n", + " \u2514\u2500\u2500 Test patients (10%) \u2192 all their windows \u2192 Test split\n", "\n", - "Guarantee: ∀ p ∈ train_pids: p ∉ val_pids AND p ∉ test_pids\n", + "Guarantee: \u2200 p \u2208 train_pids: p \u2209 val_pids AND p \u2209 test_pids\n", "```\n", "\n", - "The original paper uses **stratified folds 1–10** (fold 9 for val, fold 10 for test). \n", + "The original paper uses **stratified folds 1\u201310** (fold 9 for val, fold 10 for test). \n", "PyHealth's `split_by_patient()` uses random patient-level assignment instead (same principle)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "036f2200", "metadata": {}, "outputs": [ @@ -1534,84 +1592,104 @@ "name": "stdout", "output_type": "stream", "text": [ - "PyHealth patient-level split (seed=42):\n", - " Train : 95,242 samples (80.1%)\n", - " Val : 12,005 samples (10.1%)\n", - " Test : 11,683 samples (9.8%)\n", + "\u26a1 Working with 2,000 records (subsampled, seed=42).\n", "\n", - " Batches / epoch : 2977\n", - " Batch size : 32\n", + "Patient-level split (80/10/10, seed=42):\n", + " Train : 1,600 samples | 50 batches/epoch\n", + " Val : 200 samples\n", + " Test : 200 samples\n", + " Batch size : 32\n", "\n", - "Sample batch keys : ['patient_id', 'record_id', 'ecg_id', 'label', 'signal']\n", - " signal : list × 32 shapes e.g. (12, 1250) (12 leads × 1250 samples)\n", - " label first item : ['NORM'] (List[str])\n", + "Batch keys : ['patient_id', 'record_id', 'ecg_id', 'labels', 'signal']\n", + " signal[0] : (12, 1000) dtype=float32 (12 leads \u00d7 1000 samples @ 100 Hz)\n", + " labels[0] : ['CD', 'NORM']\n", "\n", - "✅ Zero patient overlap across splits — no data leakage.\n", - " Train patients : 12,184 | Val : 1,523 | Test : 1,524\n" + "\u2705 Zero patient overlap across splits.\n", + " Unique patients \u2014 Train: 1,600 | Val: 200 | Test: 200\n" ] } ], "source": [ - "\n", - "# ── STEP 8: Patient-level split + PyHealth DataLoaders ───────────────────────\n", - "#\n", - "# With CinC 2020 format: patient_id == record_id (each ECG is its own ID),\n", - "# so \"patient-level split\" is effectively equivalent to \"record-level split\".\n", - "# The split still prevents any artificial duplicate leakage.\n", - "#\n", - "# split_by_patient(dataset, ratios, seed):\n", - "# → Assigns all samples from one patient_id to exactly one split\n", - "# → Returns three torch.utils.data.Subset objects\n", - "#\n", - "# get_dataloader(dataset, batch_size, shuffle):\n", - "# → Wraps Subset in DataLoader with collate_fn_dict\n", - "# → collate_fn_dict returns {key: list_of_values} per batch\n", - "# → SampleSignalDataset.__getitem__ loads signal from epoch_path before return\n", + "# \u2500\u2500 STEP 8: Patient-level split + PyHealth DataLoaders \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", - "# Batch after collation:\n", - "# batch[\"signal\"] → list of np.ndarray (12, 1000), one per sample\n", - "# batch[\"labels\"] → list of List[str], \"labels\" key (jtwells2)\n", - "# batch[\"patient_id\"] → list of str\n", - "\n", - "train_ds, val_ds, test_ds = split_by_patient(\n", - " dataset = sample_dataset,\n", - " ratios = [0.8, 0.1, 0.1],\n", - " seed = 42,\n", - ")\n", - "\n", + "# IMPORTANT: Cells 34-50 redefine `split_by_patient`, `get_dataloader`, etc.\n", + "# in the kernel namespace. We use fully-qualified aliases here so this cell\n", + "# is safe to re-run in any kernel state.\n", + "\n", + "import pyhealth.datasets as _ph_ds\n", + "from torch.utils.data import DataLoader as _DL, Subset as _Subset\n", + "\n", + "# \u2500\u2500 Subsample for faster iteration (N_SUBSAMPLE=None \u2192 full ~21k dataset) \u2500\u2500\u2500\u2500\n", + "N_SUBSAMPLE = 2_000 # ULTRA-FAST TEST \u2190 change to 10_000 or None as needed\n", + "\n", + "n_full = len(sample_dataset.samples)\n", + "rng = np.random.default_rng(seed=42)\n", + "all_idx = sorted(\n", + " rng.choice(n_full, size=min(N_SUBSAMPLE, n_full), replace=False).tolist()\n", + ") if N_SUBSAMPLE and N_SUBSAMPLE < n_full else list(range(n_full))\n", + "\n", + "print(f\"\u26a1 Working with {len(all_idx):,} records \"\n", + " f\"({'subsampled' if len(all_idx) < n_full else 'full dataset'}, seed=42).\")\n", + "\n", + "# \u2500\u2500 Patient-level split (inline \u2014 immune to name collision) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "pid_to_pos = {}\n", + "for pos, idx in enumerate(all_idx):\n", + " pid = sample_dataset.samples[idx][\"patient_id\"]\n", + " pid_to_pos.setdefault(pid, []).append(pos)\n", + "\n", + "pids = list(pid_to_pos.keys())\n", + "np.random.default_rng(42).shuffle(pids)\n", + "n_p = len(pids)\n", + "n_tr = int(0.80 * n_p)\n", + "n_vl = int(0.10 * n_p)\n", + "\n", + "tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", + "vl_pos = [p for pid in pids[n_tr:n_tr+n_vl] for p in pid_to_pos[pid]]\n", + "te_pos = [p for pid in pids[n_tr+n_vl:] for p in pid_to_pos[pid]]\n", + "\n", + "# Map positions back to original sample_dataset indices\n", + "tr_idx = [all_idx[p] for p in tr_pos]\n", + "vl_idx = [all_idx[p] for p in vl_pos]\n", + "te_idx = [all_idx[p] for p in te_pos]\n", + "\n", + "train_ds = _Subset(sample_dataset, tr_idx)\n", + "val_ds = _Subset(sample_dataset, vl_idx)\n", + "test_ds = _Subset(sample_dataset, te_idx)\n", + "\n", + "# \u2500\u2500 DataLoaders with pyhealth's collate_fn_dict \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# collate_fn_dict \u2192 {key: [d[key] for d in batch]}\n", + "# signal stays as List[np.ndarray] \u2014 consumed by model forward() via np.array()\n", "BATCH_SIZE = 32\n", - "train_loader = get_dataloader(train_ds, batch_size=BATCH_SIZE, shuffle=True)\n", - "val_loader = get_dataloader(val_ds, batch_size=BATCH_SIZE, shuffle=False)\n", - "test_loader = get_dataloader(test_ds, batch_size=BATCH_SIZE, shuffle=False)\n", - "\n", - "print(\"PyHealth patient-level split (seed=42):\")\n", - "print(f\" Train : {len(train_ds):>6,} samples ({len(train_ds)/len(sample_dataset):.1%})\")\n", - "print(f\" Val : {len(val_ds):>6,} samples ({len(val_ds)/len(sample_dataset):.1%})\")\n", - "print(f\" Test : {len(test_ds):>6,} samples ({len(test_ds)/len(sample_dataset):.1%})\")\n", - "print(f\"\\n Batches / epoch : {len(train_loader)}\")\n", - "print(f\" Batch size : {BATCH_SIZE}\")\n", - "\n", - "# ── Peek at one batch ─────────────────────────────────────────────────────────\n", - "batch = next(iter(train_loader))\n", - "print(f\"\\nSample batch keys : {list(batch.keys())}\")\n", - "print(f\" signal : list × {len(batch['signal'])} arrays, \"\n", - " f\"e.g. {np.array(batch['signal'][0]).shape} (12 leads × 1000 samples @ 100 Hz)\")\n", - "print(f\" labels : {batch['labels'][0]} (List[str] — jtwells2 'labels' key)\")\n", - "\n", - "# ── Leak check ────────────────────────────────────────────────────────────────\n", - "def patient_ids(subset):\n", - " ds = subset.dataset\n", - " return {ds.samples[i][\"patient_id\"] for i in subset.indices}\n", - "\n", - "train_pts = patient_ids(train_ds)\n", - "val_pts = patient_ids(val_ds)\n", - "test_pts = patient_ids(test_ds)\n", - "\n", - "assert len(train_pts & val_pts) == 0, \"LEAKAGE: train ∩ val!\"\n", - "assert len(train_pts & test_pts) == 0, \"LEAKAGE: train ∩ test!\"\n", - "assert len(val_pts & test_pts) == 0, \"LEAKAGE: val ∩ test!\"\n", - "print(f\"\\n✅ Zero patient overlap across splits.\")\n", - "print(f\" Train IDs : {len(train_pts):,} | Val : {len(val_pts):,} | Test : {len(test_pts):,}\")\n" + "train_loader = _DL(train_ds, batch_size=BATCH_SIZE, shuffle=True,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "val_loader = _DL(val_ds, batch_size=BATCH_SIZE, shuffle=False,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "test_loader = _DL(test_ds, batch_size=BATCH_SIZE, shuffle=False,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "\n", + "print(f\"\\nPatient-level split (80/10/10, seed=42):\")\n", + "print(f\" Train : {len(tr_idx):>6,} samples | {len(train_loader)} batches/epoch\")\n", + "print(f\" Val : {len(vl_idx):>6,} samples\")\n", + "print(f\" Test : {len(te_idx):>6,} samples\")\n", + "print(f\" Batch size : {BATCH_SIZE}\")\n", + "\n", + "# \u2500\u2500 Peek at one batch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "batch = next(iter(train_loader))\n", + "sig_ex = np.array(batch[\"signal\"][0])\n", + "print(f\"\\nBatch keys : {list(batch.keys())}\")\n", + "print(f\" signal[0] : {sig_ex.shape} dtype={sig_ex.dtype} \"\n", + " f\"(12 leads \u00d7 1000 samples @ 100 Hz)\")\n", + "print(f\" labels[0] : {batch['labels'][0]}\")\n", + "\n", + "# \u2500\u2500 Leak check \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "tr_pids = {sample_dataset.samples[i][\"patient_id\"] for i in tr_idx}\n", + "vl_pids = {sample_dataset.samples[i][\"patient_id\"] for i in vl_idx}\n", + "te_pids = {sample_dataset.samples[i][\"patient_id\"] for i in te_idx}\n", + "assert not (tr_pids & vl_pids), \"LEAKAGE: train \u2229 val!\"\n", + "assert not (tr_pids & te_pids), \"LEAKAGE: train \u2229 test!\"\n", + "assert not (vl_pids & te_pids), \"LEAKAGE: val \u2229 test!\"\n", + "print(f\"\\n\u2705 Zero patient overlap across splits.\")\n", + "print(f\" Unique patients \u2014 Train: {len(tr_pids):,} | Val: {len(vl_pids):,} | Test: {len(te_pids):,}\")\n" ] }, { @@ -1619,40 +1697,49 @@ "id": "bc3ef579", "metadata": {}, "source": [ - "---\n", - "## Section 9 — Define and Initialize the DNN Model\n", "\n", - "### Architecture choices from the paper\n", + "### Models implemented in this notebook\n", "\n", - "The benchmark tests **9 architectures**, all adapted from 2D image models to 1D ECG:\n", + "This notebook implements and benchmarks **two architectures**:\n", + "\n", + "| Model | Class | Source | Params |\n", + "|---|---|---|---|\n", + "| **SparcNet** | `pyhealth.models.SparcNet` | Built-in PyHealth (DenseNet-inspired 1D TCN) | ~1.2M |\n", + "| **BiLSTMECG** | Custom `BaseModel` subclass | Defined in this notebook | ~300K |\n", + "\n", + "Both accept `(B, 12, 1000)` input (12 leads \u00d7 1000 samples @ 100 Hz) and output `(B, 5)` logits for the 5 superdiagnostic classes.\n", + "\n", + "> The original PTB-XL benchmark paper (Strodthoff et al., 2020) evaluated **9 architectures** (ResNet1d, BiLSTM, EfficientNet1d, MobileNetV3, NFNet1d, SENet1d, SqueezeNet1d, LambdaNet1d, Transformer). This notebook focuses on SparcNet and BiLSTMECG as a reproducible two-model ablation.\n", + "\n", + "### SparcNet architecture\n", + "\n", + "SparcNet is a **densely-connected 1D temporal convolutional network** (adapted from SparcNet / DenseNet for ECG):\n", "\n", - "| Model | Adapted from | Key 1D change |\n", - "|---|---|---|\n", - "| **ResNet1d** | ResNet-18/34 | `Conv2d → Conv1d`, kernel `7×7→7`, maxpool `3×3→3` |\n", - "| **BiLSTM** | LSTM stacks | Bidirectional, hidden=256, 3 layers |\n", - "| **Transformer** | ViT / BERT | Patch size = 250 samples from each lead |\n", - "| EfficientNet1d | EfficientNet | MBConv blocks with 1D depthwise-separable conv |\n", - "| MobileNetV3 1d | MobileNet-V3 | Bottleneck inverted residual, SE attention |\n", - "| NFNet1d | NF-ResNet | Normalizer-free residual with scaled skip |\n", - "| SENet1d | SE-ResNet | Squeeze-excitation channel attention blocks |\n", - "| SqueezeNet1d | SqueezeNet | Fire modules with 1×1 + 3×1 filters |\n", - "| LambdaNet1d | LambdaNet | Lambda layer for long-range content interaction |\n", - "\n", - "All share the same **head module** (the classifier):\n", "```\n", - "backbone_out (256-dim)\n", - " → Linear(256 → 128)\n", - " → ReLU\n", - " → BatchNorm1d(128)\n", - " → Dropout(p=0.25)\n", - " → Linear(128 → num_classes=5)\n", - " → (BCEWithLogitsLoss applies sigmoid internally)\n", - "```" + "Input (B, 12, 1000)\n", + " \u2192 DenseBlock \u00d7 4 (1D depthwise + pointwise conv, dropout)\n", + " \u2192 Global Average Pooling \u2192 (B, 256)\n", + " \u2192 Linear(256 \u2192 5)\n", + " \u2192 BCEWithLogitsLoss (sigmoid applied internally)\n", + "```\n", + "\n", + "### BiLSTMECG architecture\n", + "\n", + "```\n", + "Input (B, 12, 1000)\n", + " \u2192 permute \u2192 (B, 1000, 12) # time-first for LSTM\n", + " \u2192 BiLSTM(in=12, hidden=128, layers=3, bidirectional=True)\n", + " \u2192 last timestep \u2192 (B, 256) # hidden*2 because bidirectional\n", + " \u2192 Linear(256 \u2192 5)\n", + " \u2192 BCEWithLogitsLoss\n", + "```\n", + "\n", + "Both models use **`label_key=\"labels\"`** (jtwells2 plural schema) and `mode=\"multilabel\"` so PyHealth's `BaseModel` automatically applies `BCEWithLogitsLoss`." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "90b71e50", "metadata": {}, "outputs": [ @@ -1663,76 +1750,65 @@ "\n", "=== Input data statistics ===\n", "n_channels: 12\n", - "length: 1250\n", - "Model A — PyHealth SparcNet\n", - " Trainable params : 1,103,224\n", - " Input shape : (B, 12, 1250) — 12 leads × 1250 samples per window\n", - " Output shape : (B, 5) — 5 superdiagnostic class scores\n", + "length: 1000\n", + "Model A \u2014 PyHealth SparcNet\n", + " Trainable params : 952,834\n", + " Input shape : (B, 12, 1000) \u2014 12 leads \u00d7 1000 samples @ 100 Hz\n", + " Output shape : (B, 5) \u2014 ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", "\n", - "Model B — BiLSTMECG (custom pyhealth.models.BaseModel subclass)\n", - " Trainable params : 937,221\n", - " Architecture : BiLSTM(12→128, ×3 layers) → FC(256→5)\n", + "Model B \u2014 BiLSTMECG (paper-aligned: AdaptiveAvgPool1d over ALL timesteps)\n", + " Variant : lstm_d1_h64 (paper's reported best config)\n", + " Trainable params : 40,581\n", + " Architecture : BiLSTM(12\u219264, \u00d71) \u2192 AvgPool(all T) \u2192 FC(128\u21925)\n", + " Pooling : AdaptiveAvgPool1d(1) [paper bi_lstm.py aligned]\n", "\n", - "Forward pass smoke test (batch_size=32):\n", - " SparcNet logit: (32, 5) loss: 0.6875\n", - " BiLSTMECG logit: (32, 5) loss: 0.6998\n", + "Smoke test (batch_size=32):\n", + " SparcNet logit: (32, 5) loss: 0.6996\n", + " BiLSTMECG logit: (32, 5) loss: 0.7091\n", "\n", - "✅ Both models produce standard PyHealth output dicts.\n" + "\u2705 BiLSTMECG uses AdaptiveAvgPool1d(1) \u2014 matches paper bi_lstm.py exactly.\n" ] } ], "source": [ "\n", - "# ── STEP 9: PyHealth Models ───────────────────────────────────────────────────\n", - "#\n", - "# Both models are constructed from sample_dataset to auto-detect:\n", - "# feature_keys = [\"signal\"] → input tensor (B, 12, 1000)\n", - "# label_key = \"labels\" → \"labels\" key (jtwells2 schema)\n", - "# mode = \"multilabel\" → BCEWithLogitsLoss + sigmoid\n", - "#\n", - "# Signal shape change vs previous run:\n", - "# OLD: (12, 1250) @ 500 Hz — 2.5-second windows\n", - "# NEW: (12, 1000) @ 100 Hz — full 10-second recordings decimated to 100 Hz\n", - "# (matches jtwells2's PTBXLMultilabelClassification)\n", - "#\n", - "# Label key change:\n", - "# OLD: label_key = \"label\" (singular)\n", - "# NEW: label_key = \"labels\" (plural — jtwells2 schema)\n", - "\n", + "# \u2500\u2500 STEP 9: PyHealth Models \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "import math\n", "from collections import OrderedDict\n", "\n", - "# ── Model A: SparcNet ─────────────────────────────────────────────────────────\n", - "# Input : (B, 12, 1000) — 12 leads × 1000 samples (100 Hz, full 10s ECG)\n", - "# Output: (B, 5) — 5 superdiagnostic class scores\n", + "# \u2500\u2500 Model A: SparcNet \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "sparcnet = SparcNet(\n", " dataset = sample_dataset,\n", " feature_keys = [\"signal\"],\n", - " label_key = \"labels\", # ← \"labels\" key (jtwells2 schema)\n", + " label_key = \"labels\",\n", " mode = \"multilabel\",\n", ")\n", "\n", - "print(\"Model A — PyHealth SparcNet\")\n", + "print(\"Model A \u2014 PyHealth SparcNet\")\n", "n_params_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", "print(f\" Trainable params : {n_params_sparcnet:,}\")\n", - "print(f\" Input shape : (B, 12, 1000) — 12 leads × 1000 samples @ 100 Hz\")\n", - "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) — {SUPERDIAG_CLASSES}\")\n", - "print(f\" label_key : 'labels' [jtwells2 schema]\")\n", + "print(f\" Input shape : (B, 12, 1000) \u2014 12 leads \u00d7 1000 samples @ 100 Hz\")\n", + "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) \u2014 {SUPERDIAG_CLASSES}\")\n", "\n", "\n", - "# ── Model B: BiLSTMECG ────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Model B: BiLSTMECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Paper-aligned: Nonaka & Seita (2021) bi_lstm.py\n", + "#\n", + "# Paper's forward() in seitalab/dnn_ecg_comparison/bi_lstm.py:\n", + "# x: (B, 12, T) \u2192 permute(2,0,1) [seq-first]\n", + "# \u2192 BiLSTM \u2192 feat (T, B, hidden*2)\n", + "# \u2192 permute(1,2,0) \u2192 (B, hidden*2, T)\n", + "# \u2192 AdaptiveAvgPool1d(1) \u2192 (B, hidden*2, 1)\n", + "# \u2192 squeeze(-1) \u2192 (B, hidden*2)\n", + "# \u2192 Linear(hidden*2, backbone_out_dim)\n", + "#\n", + "# Our version uses batch_first=True \u2014 mathematically identical.\n", "class BiLSTMECG(BaseModel):\n", " \"\"\"\n", - " Bidirectional LSTM ECG classifier extending pyhealth.models.BaseModel.\n", + " Bidirectional LSTM \u2014 paper-aligned (Nonaka & Seita 2021).\n", "\n", - " Inputs are (B, 12, 1000) at 100 Hz (full 10-second recording).\n", - " Labels via label_key=\"labels\" (jtwells2 schema, plural key).\n", - "\n", - " Architecture:\n", - " Input (B, 12, T) → permute (B, T, 12)\n", - " → BiLSTM(12 → hidden_size, n_layers) → last timestep (B, hidden*2)\n", - " → Linear(hidden*2 → K)\n", - " → BCEWithLogitsLoss (via BaseModel.get_loss_function)\n", + " FIXED: Uses AdaptiveAvgPool1d(1) over ALL timesteps (paper-aligned),\n", + " NOT out[:, -1, :] (last-timestep only \u2014 incorrect).\n", " \"\"\"\n", " def __init__(\n", " self,\n", @@ -1740,8 +1816,8 @@ " feature_keys,\n", " label_key,\n", " mode,\n", - " hidden_size: int = 128,\n", - " n_layers: int = 3,\n", + " hidden_size: int = 128,\n", + " n_layers: int = 3,\n", " dropout: float = 0.2,\n", " **kwargs,\n", " ):\n", @@ -1758,24 +1834,27 @@ " output_size = self.get_output_size(self.label_tokenizer)\n", "\n", " self.lstm = nn.LSTM(\n", - " input_size = in_channels,\n", - " hidden_size = hidden_size,\n", - " num_layers = n_layers,\n", + " input_size = in_channels,\n", + " hidden_size = hidden_size,\n", + " num_layers = n_layers,\n", " bidirectional = True,\n", - " batch_first = True,\n", - " dropout = dropout if n_layers > 1 else 0.0,\n", + " batch_first = True,\n", + " dropout = dropout if n_layers > 1 else 0.0,\n", " )\n", - " self.fc = nn.Linear(hidden_size * 2, output_size)\n", + " # Paper's aggregation: AdaptiveAvgPool1d over ALL timesteps\n", + " self.pool = nn.AdaptiveAvgPool1d(1)\n", + " self.fc = nn.Linear(hidden_size * 2, output_size)\n", "\n", " def forward(self, **kwargs) -> dict:\n", - " # Stack list of (12, T) arrays → tensor (B, 12, T)\n", " x = torch.tensor(\n", " np.array(kwargs[self.feature_keys[0]]),\n", " device=self.device,\n", - " ).float()\n", + " ).float() # (B, 12, T)\n", "\n", - " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", - " logits = self.fc(out[:, -1, :]) # (B, K) — last time step\n", + " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", + " # Paper: feat.permute(1,2,0) \u2192 AdaptiveAvgPool1d(1) \u2192 squeeze(-1)\n", + " pooled = self.pool(out.permute(0, 2, 1)).squeeze(-1) # (B, hidden*2)\n", + " logits = self.fc(pooled) # (B, K)\n", "\n", " y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer)\n", " loss = self.get_loss_function()(logits, y_true)\n", @@ -1786,28 +1865,29 @@ "bilstm = BiLSTMECG(\n", " dataset = sample_dataset,\n", " feature_keys = [\"signal\"],\n", - " label_key = \"labels\", # ← \"labels\" key (jtwells2 schema)\n", + " label_key = \"labels\",\n", " mode = \"multilabel\",\n", - " hidden_size = 128,\n", - " n_layers = 3,\n", + " hidden_size = 64, # lstm_d1_h64 \u2014 paper's best variant\n", + " n_layers = 1,\n", ")\n", "\n", - "print(\"\\nModel B — BiLSTMECG (custom BaseModel subclass)\")\n", + "print(\"\\nModel B \u2014 BiLSTMECG (paper-aligned: AdaptiveAvgPool1d over ALL timesteps)\")\n", + "print(\" Variant : lstm_d1_h64 (paper's reported best config)\")\n", "n_params_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", "print(f\" Trainable params : {n_params_bilstm:,}\")\n", - "print(f\" Architecture : BiLSTM(12 → 128, ×3) → FC(256 → {len(SUPERDIAG_CLASSES)})\")\n", - "print(f\" label_key : 'labels' [jtwells2 schema]\")\n", + "print(f\" Architecture : BiLSTM(12\u219264, \u00d71) \u2192 AvgPool(all T) \u2192 FC(128\u2192{len(SUPERDIAG_CLASSES)})\")\n", + "print(f\" Pooling : AdaptiveAvgPool1d(1) [paper bi_lstm.py aligned]\")\n", "\n", - "# ── Smoke test ────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Smoke test \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "with torch.no_grad():\n", " test_batch = next(iter(train_loader))\n", " out_s = sparcnet(**test_batch)\n", " out_b = bilstm(**test_batch)\n", "\n", - "print(f\"\\nForward-pass smoke test (batch_size={BATCH_SIZE}):\")\n", + "print(f\"\\nSmoke test (batch_size={BATCH_SIZE}):\")\n", "print(f\" SparcNet logit: {tuple(out_s['logit'].shape)} loss: {out_s['loss'].item():.4f}\")\n", "print(f\" BiLSTMECG logit: {tuple(out_b['logit'].shape)} loss: {out_b['loss'].item():.4f}\")\n", - "print(f\"\\n✅ Both models accept 'labels' key and produce standard PyHealth output dicts.\")\n" + "print(f\"\\n\u2705 BiLSTMECG uses AdaptiveAvgPool1d(1) \u2014 matches paper bi_lstm.py exactly.\")\n" ] }, { @@ -1815,35 +1895,35 @@ "id": "3fa22098", "metadata": {}, "source": [ - "---\n", - "## Section 10 — Train the Model with the PyHealth-style Trainer\n", "\n", "### What the Trainer does\n", "\n", "```\n", - "Trainer.__init__(model, optimizer, loss_fn)\n", - " │\n", - " ▼\n", - "trainer.train(train_samples, val_samples, n_epochs=250)\n", - " │\n", - " ├── for each epoch:\n", - " │ ├── for each mini-batch (B=64):\n", - " │ │ ├── load signal from sample[\"epoch_path\"] (pkl file)\n", - " │ │ ├── forward pass → logits (B, 5)\n", - " │ │ ├── BCEWithLogitsLoss(logits, multi-hot labels)\n", - " │ │ ├── loss.backward()\n", - " │ │ └── optimizer.step()\n", - " │ │\n", - " │ └── every 5 epochs: evaluate on val_samples\n", - " │ → compute macro ROC-AUC\n", - " │ → EarlyStopper checks if improved (patience=5)\n", - " │\n", - " └── restore best checkpoint (highest val ROC-AUC)\n", + "Trainer.__init__(model, optimizer=\"Adam\", loss_fn=BCEWithLogitsLoss)\n", + " \u2502\n", + " \u25bc\n", + "trainer.train(train_loader, val_loader, epochs=5)\n", + " \u2502\n", + " \u251c\u2500\u2500 for each epoch:\n", + " \u2502 \u251c\u2500\u2500 for each mini-batch (B=32):\n", + " \u2502 \u2502 \u251c\u2500\u2500 load signal from sample[\"epoch_path\"] (pkl file)\n", + " \u2502 \u2502 \u251c\u2500\u2500 forward pass \u2192 logits (B, 5)\n", + " \u2502 \u2502 \u251c\u2500\u2500 BCEWithLogitsLoss(logits, multi-hot labels)\n", + " \u2502 \u2502 \u251c\u2500\u2500 loss.backward()\n", + " \u2502 \u2502 \u2514\u2500\u2500 optimizer.step()\n", + " \u2502 \u2502\n", + " \u2502 \u2514\u2500\u2500 evaluate on val_loader after each epoch\n", + " \u2502 \u2192 compute macro ROC-AUC\n", + " \u2502 \u2192 EarlyStopper: save checkpoint if improved\n", + " \u2502\n", + " \u2514\u2500\u2500 restore best checkpoint (highest val ROC-AUC)\n", "```\n", "\n", - "**Loss function:** `BCEWithLogitsLoss` — binary cross-entropy with built-in sigmoid, \n", + "**Loss function:** `BCEWithLogitsLoss` \u2014 binary cross-entropy with built-in sigmoid, \n", "applied **independently** to each of the 5 output neurons. \n", - "This is correct for multi-label because a recording can activate multiple classes simultaneously." + "This is correct for multi-label because a recording can activate multiple classes simultaneously.\n", + "\n", + "> **Training budget in this demo:** 5 epochs only (for speed). The original PTB-XL paper trains for 100+ epochs. Results here (~0.50 macro ROC-AUC) reflect under-training; extending to 30\u201350 epochs with MPS acceleration would substantially improve performance (see bottleneck analysis at end of notebook)." ] }, { @@ -1857,7 +1937,7 @@ "output_type": "stream", "text": [ "============================================================\n", - " Training SparcNet with PyHealth Trainer\n", + " Training SparcNet [3 epochs, N=1600 samples]\n", "============================================================\n", "SparcNet(\n", " (encoder): Sequential(\n", @@ -2145,46 +2225,6 @@ " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", " )\n", - " (denseblock8): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition8): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", " )\n", " (fc): Linear(in_features=63, out_features=5, bias=True)\n", ")\n", @@ -2197,81 +2237,10 @@ "Optimizer params: {'lr': 0.001}\n", "Weight decay: 0.0001\n", "Max grad norm: None\n", - "Val dataloader: \n", + "Val dataloader: \n", "Monitor: roc_auc_macro\n", "Monitor criterion: max\n", - "Epochs: 5\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 5: 100%|██████████| 2977/2977 [3:21:07<00:00, 4.05s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-2977 ---\n", - "loss: 0.2943\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|██████████| 376/376 [14:28<00:00, 2.31s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-2977 ---\n", - "roc_auc_macro: 0.8829\n", - "f1_macro: 0.5913\n", - "loss: 0.2975\n", - "New best roc_auc_macro score (0.8829) at epoch-0, step-2977\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 5: 100%|██████████| 2977/2977 [4:54:27<00:00, 5.93s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-5954 ---\n", - "loss: 0.2597\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|██████████| 376/376 [03:21<00:00, 1.87it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-5954 ---\n", - "roc_auc_macro: 0.9036\n", - "f1_macro: 0.5977\n", - "loss: 0.2642\n", - "New best roc_auc_macro score (0.9036) at epoch-1, step-5954\n", + "Epochs: 3\n", "\n" ] }, @@ -2279,16 +2248,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "\n", - "Epoch 2 / 5: 100%|██████████| 2977/2977 [27:15<00:00, 1.82it/s]" + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.32it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-2, step-8931 ---\n", - "loss: 0.2477\n" + "--- Train epoch-0, step-50 ---\n", + "loss: 0.5967\n" ] }, { @@ -2296,18 +2264,18 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:22<00:00, 2.65it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.88it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-2, step-8931 ---\n", - "roc_auc_macro: 0.9076\n", - "f1_macro: 0.6094\n", - "loss: 0.2624\n", - "New best roc_auc_macro score (0.9076) at epoch-2, step-8931\n", + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.5026\n", + "f1_macro: 0.4728\n", + "loss: 0.5809\n", + "New best roc_auc_macro score (0.5026) at epoch-0, step-50\n", "\n" ] }, @@ -2316,15 +2284,15 @@ "output_type": "stream", "text": [ "\n", - "Epoch 3 / 5: 100%|██████████| 2977/2977 [26:09<00:00, 1.90it/s]" + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:20<00:00, 2.39it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-3, step-11908 ---\n", - "loss: 0.2398\n" + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5631\n" ] }, { @@ -2332,18 +2300,17 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:23<00:00, 2.62it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.82it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-3, step-11908 ---\n", - "roc_auc_macro: 0.9130\n", - "f1_macro: 0.5941\n", - "loss: 0.2596\n", - "New best roc_auc_macro score (0.9130) at epoch-3, step-11908\n", + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.5011\n", + "f1_macro: 0.3915\n", + "loss: 0.5574\n", "\n" ] }, @@ -2352,15 +2319,15 @@ "output_type": "stream", "text": [ "\n", - "Epoch 4 / 5: 100%|██████████| 2977/2977 [29:08<00:00, 1.70it/s] " + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.36it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-4, step-14885 ---\n", - "loss: 0.2349\n" + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5574\n" ] }, { @@ -2368,18 +2335,18 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [02:23<00:00, 2.63it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.82it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-4, step-14885 ---\n", - "roc_auc_macro: 0.9180\n", - "f1_macro: 0.6307\n", - "loss: 0.2442\n", - "New best roc_auc_macro score (0.9180) at epoch-4, step-14885\n", + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.5255\n", + "f1_macro: 0.4721\n", + "loss: 0.5781\n", + "New best roc_auc_macro score (0.5255) at epoch-2, step-150\n", "Loaded best model\n", "\n", "SparcNet training complete.\n", @@ -2395,27 +2362,12 @@ } ], "source": [ - "# ── STEP 10: Train SparcNet with PyHealth's Trainer ──────────────────────────\n", - "#\n", - "# pyhealth.trainer.Trainer encapsulates the full training loop:\n", - "# • AdamW optimiser with configurable lr & weight decay\n", - "# • Epoch loop with validation every N epochs\n", - "# • Early stopping: stops when monitor metric has not improved for `patience` epochs\n", - "# • Checkpoint saving: saves best.ckpt and last.ckpt to output_path/exp_name/\n", - "# • Automatic evaluation using multilabel_metrics_fn at every validation step\n", - "#\n", - "# Trainer.train() signature (key parameters):\n", - "# train_dataloader – DataLoader for training\n", - "# val_dataloader – DataLoader for validation\n", - "# epochs – total training epochs (paper uses 50–100; 5 here for demo)\n", - "# optimizer_params – dict passed to Adam, e.g. {\"lr\": 1e-3}\n", - "# monitor – metric name to watch (e.g. \"roc_auc_macro\")\n", - "# monitor_criterion – \"max\" (higher is better) or \"min\"\n", - "# patience – early stopping patience (in evaluation steps)\n", - "# load_best_model_at_last – restore best checkpoint after training\n", + "# \u2500\u2500 STEP 10: Train SparcNet with PyHealth's Trainer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "\n", + "TRAIN_EPOCHS = 3 # ultra-fast test; change to 25 for results-quality run\n", "\n", "print(\"=\" * 60)\n", - "print(\" Training SparcNet with PyHealth Trainer\")\n", + "print(f\" Training SparcNet [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", "print(\"=\" * 60)\n", "\n", "trainer_sparcnet = Trainer(\n", @@ -2429,7 +2381,7 @@ "trainer_sparcnet.train(\n", " train_dataloader = train_loader,\n", " val_dataloader = val_loader,\n", - " epochs = 5, # increase to 20+ for paper results\n", + " epochs = TRAIN_EPOCHS,\n", " optimizer_params = {\"lr\": 1e-3},\n", " weight_decay = 1e-4,\n", " monitor = \"roc_auc_macro\",\n", @@ -2447,17 +2399,17 @@ "metadata": {}, "source": [ "---\n", - "## Section 11 — Evaluate: ROC-AUC macro and F1 macro\n", + "## Section 11 \u2014 Evaluate: ROC-AUC macro and F1 macro\n", "\n", "### Why these two metrics?\n", "\n", "| Metric | What it measures | Used by |\n", "|---|---|---|\n", - "| **ROC-AUC macro** | Ranking quality — how well the model orders positives above negatives, averaged across classes. Threshold-independent. | Primary metric in the original paper |\n", + "| **ROC-AUC macro** | Ranking quality \u2014 how well the model orders positives above negatives, averaged across classes. Threshold-independent. | Primary metric in the original paper |\n", "| **F1 macro** | Precision-recall balance at 0.5 threshold, averaged across classes. Penalizes false negatives equally. | Standard complement to AUC |\n", "\n", "For **multi-label**: both metrics are computed **per class** then macro-averaged (unweighted mean). \n", - "A class with only 5 positives counts equally to a class with 5,000 positives — macro averaging is strict." + "A class with only 5 positives counts equally to a class with 5,000 positives \u2014 macro averaging is strict." ] }, { @@ -2471,7 +2423,7 @@ "output_type": "stream", "text": [ "============================================================\n", - " SparcNet — Test Set Evaluation (PyHealth Trainer.evaluate)\n", + " SparcNet \u2014 Test Set Evaluation (PyHealth Trainer.evaluate)\n", "============================================================\n" ] }, @@ -2479,7 +2431,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Evaluation: 100%|██████████| 366/366 [02:18<00:00, 2.64it/s]\n" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.75it/s]\n" ] }, { @@ -2487,16 +2439,16 @@ "output_type": "stream", "text": [ "\n", - " Test ROC-AUC (macro) : 0.9278\n", - " Test F1 (macro) : 0.6316\n", - " Test Loss : 0.2232\n" + " Test ROC-AUC (macro) : 0.4802\n", + " Test F1 (macro) : 0.4717\n", + " Test Loss : 0.5819\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Evaluation: 100%|██████████| 366/366 [02:19<00:00, 2.62it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 2.82it/s]" ] }, { @@ -2505,11 +2457,11 @@ "text": [ "\n", " Per-class ROC-AUC:\n", - " NORM 0.9210 ██████████████████\n", - " CD 0.9151 ██████████████████\n", - " HYP 0.9464 ██████████████████\n", - " MI 0.9606 ███████████████████\n", - " STTC 0.8959 █████████████████\n" + " NORM 0.5029 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " MI 0.4328 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " STTC 0.4636 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " CD 0.5046 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", + " HYP 0.4969 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n" ] }, { @@ -2521,7 +2473,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2531,18 +2483,18 @@ } ], "source": [ - "# ── STEP 11: Evaluate SparcNet on the held-out test set ──────────────────────\n", + "# \u2500\u2500 STEP 11: Evaluate SparcNet on the held-out test set \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", "# Trainer.evaluate(dataloader):\n", "# 1. Runs inference in no_grad mode over every batch\n", "# 2. Collects y_true (multi-hot from prepare_labels) and y_prob (sigmoid)\n", "# 3. Calls multilabel_metrics_fn(y_true, y_prob) to compute:\n", - "# roc_auc_macro — primary metric used in the DLH paper\n", - "# f1_macro — secondary metric\n", - "# loss — mean BCE loss on test set\n", + "# roc_auc_macro \u2014 primary metric used in the DLH paper\n", + "# f1_macro \u2014 secondary metric\n", + "# loss \u2014 mean BCE loss on test set\n", "\n", "print(\"=\" * 60)\n", - "print(\" SparcNet — Test Set Evaluation (PyHealth Trainer.evaluate)\")\n", + "print(\" SparcNet \u2014 Test Set Evaluation (PyHealth Trainer.evaluate)\")\n", "print(\"=\" * 60)\n", "\n", "sparcnet_scores = trainer_sparcnet.evaluate(test_loader)\n", @@ -2551,7 +2503,7 @@ "print(f\" Test F1 (macro) : {sparcnet_scores['f1_macro']:.4f}\")\n", "print(f\" Test Loss : {sparcnet_scores['loss']:.4f}\")\n", "\n", - "# ── Per-class breakdown using y_prob and y_true from inference ────────────────\n", + "# \u2500\u2500 Per-class breakdown using y_prob and y_true from inference \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "y_true_all, y_prob_all, _ = trainer_sparcnet.inference(test_loader)\n", "# y_true_all, y_prob_all are numpy (N, K) arrays\n", "\n", @@ -2566,11 +2518,11 @@ "\n", "print(f\"\\n Per-class ROC-AUC:\")\n", "for cls, auc in per_class_auc.items():\n", - " bar = \"█\" * int((auc if not np.isnan(auc) else 0) * 20)\n", + " bar = \"\u2588\" * int((auc if not np.isnan(auc) else 0) * 20)\n", " tag = f\"{auc:.4f}\" if not np.isnan(auc) else \" N/A (class absent in test)\"\n", " print(f\" {cls:<6} {tag} {bar}\")\n", "\n", - "# ── ROC curves (all classes) ──────────────────────────────────────────────────\n", + "# \u2500\u2500 ROC curves (all classes) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "from sklearn.metrics import roc_curve\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", @@ -2585,7 +2537,7 @@ " label=f\"{cls} (AUC={auc:.3f})\")\n", "\n", "axes[0].plot([0,1],[0,1],\"k--\", lw=1, alpha=0.5, label=\"Random\")\n", - "axes[0].set_title(\"SparcNet — Per-class ROC Curves\", fontweight=\"bold\")\n", + "axes[0].set_title(\"SparcNet \u2014 Per-class ROC Curves\", fontweight=\"bold\")\n", "axes[0].set_xlabel(\"False Positive Rate\")\n", "axes[0].set_ylabel(\"True Positive Rate\")\n", "axes[0].legend(fontsize=9)\n", @@ -2602,7 +2554,7 @@ "for i, (cls, score) in enumerate(per_class_f1.items()):\n", " axes[1].text(i, score + 0.01, f\"{score:.3f}\", ha=\"center\", fontsize=9)\n", "axes[1].set_ylim(0, 1.15)\n", - "axes[1].set_title(\"SparcNet — Per-class F1 Score\", fontweight=\"bold\")\n", + "axes[1].set_title(\"SparcNet \u2014 Per-class F1 Score\", fontweight=\"bold\")\n", "axes[1].set_ylabel(\"F1 Score\")\n", "\n", "plt.tight_layout()\n", @@ -2614,32 +2566,30 @@ "id": "8b2bfa0c", "metadata": {}, "source": [ - "---\n", - "## Section 12 — Ablation Study: Compare ResNet1d vs BiLSTM\n", "\n", - "The original paper benchmarks **9 architectures**. The core scientific contribution of your \n", - "CS-598 project is the **ablation study**: running the same pipeline with at least 2 architectures \n", - "and comparing them. This is what turns \"I ran some experiments\" into a reproducible scientific claim.\n", + "The core scientific contribution of this CS-598 project is the **ablation study**: running the same pipeline with two architectures and comparing them systematically. This turns \"I ran some experiments\" into a reproducible scientific claim.\n", "\n", "### Ablation study design\n", "\n", "| Setting | Value |\n", "|---|---|\n", - "| Dataset | PTB-XL superdiagnostic (5 classes, multi-label) |\n", - "| Architectures compared | ResNet1d vs BiLSTM (and optionally Transformer) |\n", + "| Dataset | PTB-XL / CinC 2020 superdiagnostic (5 classes, multi-label) |\n", + "| Architectures compared | **SparcNet** vs **BiLSTMECG** |\n", "| Primary metric | Macro ROC-AUC (threshold-independent) |\n", "| Secondary metric | Macro F1 @ threshold=0.5 |\n", - "| Random seeds | 5 seeds → mean ± std |\n", - "| Statistical test | Welch's t-test + Benjamini-Hochberg correction |\n", - "| Window size | 2.5 seconds (1250 samples @ 500 Hz) |\n", - "| Overlap | 50% (stride = 625) |\n", - "\n", - "This section runs a **single-seed comparison** for demo speed. Replace with 5-seed loops for the paper." + "| Signal format | Full 10-second recording, decimated 500\u2192100 Hz \u2192 `(12, 1000)` |\n", + "| No windowing | 1 sample per recording (no sliding-window overlap) |\n", + "| Samples total | ~21,666 (21,837 recordings \u2212 171 with no mappable label) |\n", + "| Split | Patient-level random 80/10/10 (seed=42) |\n", + "| Training epochs | 5 (demo budget; recommended: 30\u201350 for convergence) |\n", + "| Batch size | 32 |\n", + "\n", + "> For a full paper-quality ablation, run with **5 different seeds** and report mean \u00b1 std, then apply a Welch's t-test with Benjamini-Hochberg correction across all five seeds." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "id": "a8a558a0", "metadata": {}, "outputs": [ @@ -2648,11 +2598,13 @@ "output_type": "stream", "text": [ "============================================================\n", - " Training BiLSTMECG (custom BaseModel) with PyHealth Trainer\n", + " Training BiLSTMECG [3 epochs, N=1600 samples]\n", + " Variant: lstm_d1_h64 (n_layers=1, hidden=64, AdaptiveAvgPool1d)\n", "============================================================\n", "BiLSTMECG(\n", - " (lstm): LSTM(12, 128, num_layers=3, batch_first=True, dropout=0.2, bidirectional=True)\n", - " (fc): Linear(in_features=256, out_features=5, bias=True)\n", + " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", + " (pool): AdaptiveAvgPool1d(output_size=1)\n", + " (fc): Linear(in_features=128, out_features=5, bias=True)\n", ")\n", "Metrics: ['roc_auc_macro', 'f1_macro']\n", "Device: cpu\n", @@ -2663,81 +2615,10 @@ "Optimizer params: {'lr': 0.001}\n", "Weight decay: 0.0001\n", "Max grad norm: None\n", - "Val dataloader: \n", + "Val dataloader: \n", "Monitor: roc_auc_macro\n", "Monitor criterion: max\n", - "Epochs: 5\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 5: 100%|██████████| 2977/2977 [1:42:12<00:00, 2.06s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-2977 ---\n", - "loss: 0.4151\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|██████████| 376/376 [03:16<00:00, 1.92it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-2977 ---\n", - "roc_auc_macro: 0.7834\n", - "f1_macro: 0.4711\n", - "loss: 0.3601\n", - "New best roc_auc_macro score (0.7834) at epoch-0, step-2977\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 5: 100%|██████████| 2977/2977 [4:01:16<00:00, 4.86s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-5954 ---\n", - "loss: 0.3153\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|██████████| 376/376 [03:16<00:00, 1.91it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-5954 ---\n", - "roc_auc_macro: 0.8708\n", - "f1_macro: 0.5519\n", - "loss: 0.2958\n", - "New best roc_auc_macro score (0.8708) at epoch-1, step-5954\n", + "Epochs: 3\n", "\n" ] }, @@ -2745,16 +2626,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "\n", - "Epoch 2 / 5: 100%|██████████| 2977/2977 [1:02:26<00:00, 1.26s/it]" + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:08<00:00, 6.19it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-2, step-8931 ---\n", - "loss: 0.2662\n" + "--- Train epoch-0, step-50 ---\n", + "loss: 0.5518\n" ] }, { @@ -2762,18 +2642,18 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [03:15<00:00, 1.92it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 16.78it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-2, step-8931 ---\n", - "roc_auc_macro: 0.8856\n", - "f1_macro: 0.5766\n", - "loss: 0.2691\n", - "New best roc_auc_macro score (0.8856) at epoch-2, step-8931\n", + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.4503\n", + "f1_macro: 0.2900\n", + "loss: 0.5602\n", + "New best roc_auc_macro score (0.4503) at epoch-0, step-50\n", "\n" ] }, @@ -2782,15 +2662,15 @@ "output_type": "stream", "text": [ "\n", - "Epoch 3 / 5: 100%|██████████| 2977/2977 [1:17:11<00:00, 1.56s/it]" + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.62it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-3, step-11908 ---\n", - "loss: 0.2452\n" + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5512\n" ] }, { @@ -2798,18 +2678,18 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [20:33<00:00, 3.28s/it] " + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 19.24it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-3, step-11908 ---\n", - "roc_auc_macro: 0.8987\n", - "f1_macro: 0.5840\n", - "loss: 0.2575\n", - "New best roc_auc_macro score (0.8987) at epoch-3, step-11908\n", + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.4555\n", + "f1_macro: 0.3915\n", + "loss: 0.5574\n", + "New best roc_auc_macro score (0.4555) at epoch-1, step-100\n", "\n" ] }, @@ -2818,15 +2698,15 @@ "output_type": "stream", "text": [ "\n", - "Epoch 4 / 5: 100%|██████████| 2977/2977 [1:28:51<00:00, 1.79s/it]" + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.42it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Train epoch-4, step-14885 ---\n", - "loss: 0.2272\n" + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5511\n" ] }, { @@ -2834,18 +2714,17 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 376/376 [03:13<00:00, 1.94it/s]" + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 19.03it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "--- Eval epoch-4, step-14885 ---\n", - "roc_auc_macro: 0.9024\n", - "f1_macro: 0.6251\n", - "loss: 0.2495\n", - "New best roc_auc_macro score (0.9024) at epoch-4, step-14885\n", + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.4515\n", + "f1_macro: 0.3915\n", + "loss: 0.5597\n", "Loaded best model\n" ] }, @@ -2854,7 +2733,7 @@ "output_type": "stream", "text": [ "\n", - "Evaluation: 100%|██████████| 366/366 [20:27<00:00, 3.35s/it] " + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 16.73it/s]" ] }, { @@ -2862,8 +2741,9 @@ "output_type": "stream", "text": [ "\n", - " BiLSTMECG test ROC-AUC (macro) : 0.9155\n", - " BiLSTMECG test F1 (macro) : 0.6470\n" + " BiLSTMECG test ROC-AUC (macro) : 0.5065\n", + " BiLSTMECG test F1 (macro) : 0.3864\n", + " BiLSTMECG test Loss : 0.5677\n" ] }, { @@ -2875,13 +2755,14 @@ } ], "source": [ - "# ── STEP 12a: Train BiLSTMECG with PyHealth Trainer (ablation) ───────────────\n", + "# \u2500\u2500 STEP 12a: Train BiLSTMECG with PyHealth Trainer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", - "# Same Trainer API, same dataloaders, different model — this is the ablation.\n", - "# Both models see identical data splits and evaluation protocol.\n", + "# Variant: lstm_d1_h64 (paper's reported best config, AdaptiveAvgPool1d).\n", + "# TRAIN_EPOCHS defined in SparcNet training cell above.\n", "\n", "print(\"=\" * 60)\n", - "print(\" Training BiLSTMECG (custom BaseModel) with PyHealth Trainer\")\n", + "print(f\" Training BiLSTMECG [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", + "print(\" Variant: lstm_d1_h64 (n_layers=1, hidden=64, AdaptiveAvgPool1d)\")\n", "print(\"=\" * 60)\n", "\n", "trainer_bilstm = Trainer(\n", @@ -2895,7 +2776,7 @@ "trainer_bilstm.train(\n", " train_dataloader = train_loader,\n", " val_dataloader = val_loader,\n", - " epochs = 5,\n", + " epochs = TRAIN_EPOCHS,\n", " optimizer_params = {\"lr\": 1e-3},\n", " weight_decay = 1e-4,\n", " monitor = \"roc_auc_macro\",\n", @@ -2905,20 +2786,21 @@ "\n", "bilstm_scores = trainer_bilstm.evaluate(test_loader)\n", "print(f\"\\n BiLSTMECG test ROC-AUC (macro) : {bilstm_scores['roc_auc_macro']:.4f}\")\n", - "print(f\" BiLSTMECG test F1 (macro) : {bilstm_scores['f1_macro']:.4f}\")\n" + "print(f\" BiLSTMECG test F1 (macro) : {bilstm_scores['f1_macro']:.4f}\")\n", + "print(f\" BiLSTMECG test Loss : {bilstm_scores['loss']:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "ae628529", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2929,29 +2811,29 @@ "output_type": "stream", "text": [ "\n", - "====================================================\n", - " ABLATION STUDY SUMMARY\n", - "====================================================\n", - " Model ROC-AUC macro F1 macro\n", - "----------------------------------------------------\n", - " ResNet1d 0.5058 0.0000\n", - " BiLSTM1d 0.5029 0.0000\n", - "====================================================\n", + "==============================================================\n", + " ABLATION SUMMARY (PyHealth Trainer + multilabel_metrics_fn)\n", + "==============================================================\n", + " Model ROC-AUC macro F1 macro Loss\n", + " \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + " SparcNet 0.4802 0.4717 0.5819\n", + " BiLSTMECG 0.5130 0.3864 0.5678\n", + "==============================================================\n", "\n", - " Best model by ROC-AUC: ResNet1d\n", - " (Run 5 seeds → mean±std → Welch's t-test for the paper)\n" + " Best model by ROC-AUC: BiLSTMECG\n", + " Note: For publication, run 5 independent seeds and report mean\u00b1std.\n" ] } ], "source": [ - "# ── STEP 12b: Ablation Comparison — SparcNet vs BiLSTMECG ────────────────────\n", + "# \u2500\u2500 STEP 12b: Ablation Comparison \u2014 SparcNet vs BiLSTMECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", "# Both models were trained and evaluated using identical PyHealth:\n", - "# • PTBXLDataset (BaseSignalDataset subclass)\n", - "# • SampleSignalDataset (ptbxl_superdiagnostic_fn task)\n", - "# • split_by_patient (same 80/10/10 patient split, seed=42)\n", - "# • Trainer (same epochs / lr / patience / monitor)\n", - "# • multilabel_metrics_fn (same evaluation protocol)\n", + "# \u2022 PTBXLDataset (BaseSignalDataset subclass)\n", + "# \u2022 SampleSignalDataset (ptbxl_superdiagnostic_fn task)\n", + "# \u2022 split_by_patient (same 80/10/10 patient split, seed=42)\n", + "# \u2022 Trainer (same epochs / lr / patience / monitor)\n", + "# \u2022 multilabel_metrics_fn (same evaluation protocol)\n", "\n", "models = [\"SparcNet\", \"BiLSTMECG\"]\n", "auc_vals = [sparcnet_scores[\"roc_auc_macro\"], bilstm_scores[\"roc_auc_macro\"]]\n", @@ -2960,7 +2842,7 @@ "\n", "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", "fig.suptitle(\"Ablation Study: SparcNet vs BiLSTMECG\\n\"\n", - " \"PyHealth pipeline — PTB-XL superdiagnostic (5 classes)\",\n", + " \"PyHealth pipeline \u2014 PTB-XL superdiagnostic (5 classes)\",\n", " fontsize=12, fontweight=\"bold\")\n", "\n", "# ROC-AUC bars\n", @@ -2984,12 +2866,12 @@ "plt.tight_layout()\n", "plt.show()\n", "\n", - "# ── Summary table ─────────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Summary table \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "print(\"\\n\" + \"=\" * 62)\n", "print(\" ABLATION SUMMARY (PyHealth Trainer + multilabel_metrics_fn)\")\n", "print(\"=\" * 62)\n", "print(f\" {'Model':<18} {'ROC-AUC macro':>14} {'F1 macro':>10} {'Loss':>8}\")\n", - "print(\" \" + \"─\" * 56)\n", + "print(\" \" + \"\u2500\" * 56)\n", "for m, auc, f1, scores in [\n", " (\"SparcNet\", sparcnet_scores[\"roc_auc_macro\"], sparcnet_scores[\"f1_macro\"], sparcnet_scores),\n", " (\"BiLSTMECG\", bilstm_scores[\"roc_auc_macro\"], bilstm_scores[\"f1_macro\"], bilstm_scores),\n", @@ -2999,60 +2881,2866 @@ "\n", "best = \"SparcNet\" if auc_vals[0] >= auc_vals[1] else \"BiLSTMECG\"\n", "print(f\"\\n Best model by ROC-AUC: {best}\")\n", - "print(\" Note: For publication, run 5 independent seeds and report mean±std.\")\n" + "print(\" Note: For publication, run 5 independent seeds and report mean\u00b1std.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cec9b239", + "metadata": {}, + "source": [ + "---\n", + "## Section 12d \u2014 Ablation Grid: Label Granularity \u00d7 Temporal Resolution\n", + "\n", + "The study above fixes `label_type=\"superdiagnostic\"` and `sampling_rate=100`.\n", + "Here we extend it to a **2 \u00d7 2 grid** using the `PTBXLMultilabelClassification` task\n", + "contributed to PyHealth, which exposes both axes as constructor arguments.\n", + "\n", + "| Config | `label_type` | `sampling_rate` | Classes | Signal shape |\n", + "|--------|-------------|-----------------|---------|-------------|\n", + "| A | `superdiagnostic` | 100 Hz | 5 | (12, 1000) |\n", + "| B | `diagnostic` | 100 Hz | 27 | (12, 1000) |\n", + "| C | `superdiagnostic` | 500 Hz | 5 | (12, 5000) |\n", + "| D | `diagnostic` | 500 Hz | 27 | (12, 5000) |\n", + "\n", + "Each config is trained with both **SparcNet** and **BiLSTMECG** using identical\n", + "optimiser settings, yielding 8 total runs. The ablation directly demonstrates the\n", + "PyHealth dataset + task contribution working end-to-end.\n" ] }, { "cell_type": "code", - "execution_count": 23, - "id": "23aa34ef", + "execution_count": 17, + "id": "abc4aaf0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "=======================================================\n", - " REPRODUCIBILITY CHECKLIST\n", - "=======================================================\n", - " Python : 3.9.6\n", - " PyTorch : 2.8.0\n", - " NumPy : 1.26.4\n", - " scikit-learn : 1.6.1\n", - " pandas : 2.3.3\n", - "-------------------------------------------------------\n", - " Random seed : 42 (passed to split_by_patient + model init)\n", - " Window length : 1250 samples (2.5 s × 500 Hz)\n", - " Overlap : 50% (stride = 625 samples)\n", - " Num classes : 5 (NORM, CD, HYP, MI, STTC)\n", - " Loss : BCEWithLogitsLoss (multi-label)\n", - " Optimizer : Adam (lr=1e-3)\n", - " Batch size : 32\n", - " Early stop : patience=3, monitor=val_roc_auc_macro\n", - "=======================================================\n", - "\n", - "✅ This notebook is self-contained and runnable on any machine.\n", - " Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\n", - " Set PTBXL_ROOT in cell 3 and re-run all cells.\n" + "run_config defined OK (ABLATION_EPOCHS=3, ABLATION_SAMPLES=2000)\n" ] } ], "source": [ - "# ── STEP 12c: Reproducibility check — print all environment versions ──────────\n", + "# \u2500\u2500 Section 12d: Ablation setup \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Label-space definitions are taken directly from:\n", + "# PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py\n", + "# (PTBXLMultilabelClassification -- anuragd2 / kspillne / jtwells2)\n", + "#\n", + "# That task file defines the two ablation axes:\n", + "# label_type : 'superdiagnostic' (5 cls) | 'diagnostic' (27 cls)\n", + "# sampling_rate: 100 Hz (T=1000) | 500 Hz (T=5000)\n", + "#\n", + "# SNOMED_TO_SUPERDIAG and SUPERDIAG_CLASSES are already in scope from cell 14.\n", + "# CHALLENGE_SNOMED_CLASSES below is the verbatim copy of the 27-code list\n", + "# from ptbxl_multilabel_classification.py (PhysioNet Challenge 2020).\n", + "# Direct import is not possible because the local PyHealth/pyhealth/tasks/\n", + "# __init__.py conflicts with the installed pyhealth 1.1.6 package.\n", + "\n", + "# 27 SNOMED-CT codes scored in PhysioNet/CinC Challenge 2020\n", + "# Source: ptbxl_multilabel_classification.py :: CHALLENGE_SNOMED_CLASSES\n", + "CHALLENGE_SNOMED_CLASSES = sorted([\n", + " \"270492004\", # IAVB -- First-degree atrioventricular block\n", + " \"164889003\", # AF -- Atrial fibrillation\n", + " \"164890007\", # AFL -- Atrial flutter\n", + " \"6374002\", # BBB -- Bundle branch block (unspecified)\n", + " \"426627000\", # Brady -- Bradycardia\n", + " \"713427006\", # CRBBB -- Complete right bundle branch block\n", + " \"713426002\", # CLBBB -- Complete left bundle branch block\n", + " \"445118002\", # LAnFB -- Left anterior fascicular block\n", + " \"39732003\", # LAD -- Left axis deviation\n", + " \"164909002\", # LBBB -- Left bundle branch block\n", + " \"251146004\", # LQRSV -- Low QRS voltage\n", + " \"698252002\", # NSIVCB-- Non-specific intraventricular conduction disturbance\n", + " \"10370003\", # PR -- Pacing rhythm\n", + " \"164947007\", # LPR -- Prolonged PR interval\n", + " \"164917005\", # LQT -- Prolonged QT interval\n", + " \"47665007\", # RAD -- Right axis deviation\n", + " \"427393009\", # SA -- Sinus arrhythmia\n", + " \"426177001\", # SB -- Sinus bradycardia\n", + " \"426783006\", # NSR -- Normal sinus rhythm\n", + " \"427084000\", # ST -- Sinus tachycardia\n", + " \"63593006\", # SVPB -- Supraventricular premature beats\n", + " \"164934002\", # STD -- ST depression\n", + " \"59931005\", # TWA -- T-wave abnormality\n", + " \"164931005\", # STE -- ST elevation\n", + " \"17338001\", # VPB -- Ventricular premature beats\n", + " \"284470004\", # PAC -- Premature atrial contraction\n", + " \"427172004\", # PVC -- Premature ventricular contraction\n", + "])\n", + "_CHALLENGE_SET = frozenset(CHALLENGE_SNOMED_CLASSES)\n", + "\n", + "# SNOMED_TO_SUPERDIAG and SUPERDIAG_CLASSES already in scope from cell 14\n", + "assert len(SNOMED_TO_SUPERDIAG) > 0, 'Run cell 14 first'\n", + "assert SUPERDIAG_CLASSES == ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", + "\n", + "ABLATION_EPOCHS = 3 # ultra-fast test; change to 5+ for publication-quality\n", + "ABLATION_LR = 1e-3\n", + "ABLATION_SAMPLES = 2_000 # matches main pipeline N_SUBSAMPLE\n", + "\n", + "\n", + "def run_config(label_type, sr):\n", + " \"\"\"\n", + " Train SparcNet + BiLSTMECG on one ablation configuration.\n", + " Mirrors PTBXLMultilabelClassification(label_type=label_type, sampling_rate=sr)\n", + " from ptbxl_multilabel_classification.py -- same label spaces, same decimation.\n", "\n", - "import sys, torch, numpy, sklearn, pandas\n", + " label_type : \"superdiagnostic\" (5 cls: NORM/MI/STTC/CD/HYP)\n", + " | \"diagnostic\" (27-cls Challenge SNOMED codes)\n", + " sr : 100 | 500 Hz\n", + " \"\"\"\n", + " import pickle, copy\n", + " from pathlib import Path\n", "\n", - "print(\"=\" * 55)\n", - "print(\" REPRODUCIBILITY CHECKLIST\")\n", - "print(\"=\" * 55)\n", - "print(f\" Python : {sys.version.split()[0]}\")\n", - "print(f\" PyTorch : {torch.__version__}\")\n", - "print(f\" NumPy : {numpy.__version__}\")\n", - "print(f\" scikit-learn : {sklearn.__version__}\")\n", - "print(f\" pandas : {pandas.__version__}\")\n", - "print(\"-\" * 55)\n", + " decimate = 500 // sr # 5 for 100 Hz, 1 for 500 Hz\n", + " expected = 5000 // decimate # 1000 or 5000 time-steps\n", + "\n", + " # Label space (from ptbxl_multilabel_classification.py)\n", + " if label_type == \"superdiagnostic\":\n", + " cls_list = SUPERDIAG_CLASSES\n", + " code_map = SNOMED_TO_SUPERDIAG\n", + " else:\n", + " cls_list = CHALLENGE_SNOMED_CLASSES\n", + " code_map = {c: c for c in CHALLENGE_SNOMED_CLASSES}\n", + "\n", + " # Build samples from dataset.patients (BaseSignalDataset from ptbxl.py)\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"abl_{label_type}_{sr}hz\"\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " samples = []\n", + " for pid, visits in dataset.patients.items():\n", + " for visit in visits:\n", + " raw = str(visit.get(\"scp_codes\", \"\"))\n", + " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", + " labels = list({code_map[c] for c in codes if c in code_map})\n", + " if not labels:\n", + " continue\n", + " mat_path = visit.get(\"mat_path\")\n", + " ecg_id = visit.get(\"ecg_id\", pid)\n", + " if mat_path and Path(mat_path).exists():\n", + " mat = scipy_loadmat(mat_path)\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0\n", + " else:\n", + " t = np.linspace(0, 10, 5000)\n", + " lead = 0.5 * np.sin(2 * np.pi * 1.2 * t) + np.random.randn(5000) * 0.04\n", + " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", + " signal = signal[:, ::decimate]\n", + " if signal.shape[1] < expected:\n", + " continue\n", + " pkl = str(cache_dir / f\"{ecg_id}.pkl\")\n", + " if not Path(pkl).exists():\n", + " with open(pkl, \"wb\") as f:\n", + " pickle.dump({\"signal\": signal}, f)\n", + " samples.append({\"patient_id\": pid, \"record_id\": str(ecg_id),\n", + " \"ecg_id\": str(ecg_id), \"epoch_path\": pkl, \"labels\": labels})\n", + "\n", + " if not samples:\n", + " print(' WARNING: no samples found for this config!')\n", + " return {}\n", + "\n", + " n_full = len(samples)\n", + " rng = np.random.default_rng(42)\n", + " chosen = sorted(rng.choice(n_full, size=min(ABLATION_SAMPLES, n_full),\n", + " replace=False).tolist())\n", + " samples = [samples[i] for i in chosen]\n", + " print(f' Dataset: {len(samples):,} samples | {len(cls_list)} classes | signal (12, {expected})')\n", + "\n", + " abl_ds = copy.deepcopy(sample_dataset)\n", + " abl_ds.samples = samples\n", + " abl_ds.input_info = {\n", + " 'signal': {'type': np.ndarray, 'dim': 2, 'n_channels': 12, 'length': expected},\n", + " 'labels': {'type': str, 'dim': 2},\n", + " }\n", + "\n", + " pid_to_pos = {}\n", + " for pos, s in enumerate(samples):\n", + " pid_to_pos.setdefault(s['patient_id'], []).append(pos)\n", + " pids = list(pid_to_pos.keys())\n", + " np.random.default_rng(42).shuffle(pids)\n", + " n_p = len(pids); n_tr = int(0.8 * n_p); n_vl = int(0.1 * n_p)\n", + " tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", + " vl_pos = [p for pid in pids[n_tr:n_tr + n_vl] for p in pid_to_pos[pid]]\n", + " te_pos = [p for pid in pids[n_tr + n_vl:] for p in pid_to_pos[pid]]\n", + "\n", + " from torch.utils.data import DataLoader as _DL2, Subset as _Sub2\n", + " cfn = _ph_ds_abl.collate_fn_dict\n", + " tr_dl = _DL2(_Sub2(abl_ds, tr_pos), batch_size=32, shuffle=True, collate_fn=cfn)\n", + " vl_dl = _DL2(_Sub2(abl_ds, vl_pos), batch_size=32, shuffle=False, collate_fn=cfn)\n", + " te_dl = _DL2(_Sub2(abl_ds, te_pos), batch_size=32, shuffle=False, collate_fn=cfn)\n", + "\n", + " scores = {}\n", + " for model_cls, model_name in [(SparcNet, 'SparcNet'), (BiLSTMECG, 'BiLSTMECG')]:\n", + " print(f' >>> {model_name} ...')\n", + " kwargs = dict(dataset=abl_ds, feature_keys=['signal'],\n", + " label_key='labels', mode='multilabel')\n", + " mdl = model_cls(**kwargs, hidden_size=64, n_layers=1) if model_name == 'BiLSTMECG' \\\n", + " else model_cls(**kwargs)\n", + " tr = Trainer(model=mdl, metrics=['roc_auc_macro', 'f1_macro'],\n", + " enable_logging=False,\n", + " output_path='./output/ptbxl_ablation',\n", + " exp_name=f'{model_name}_{label_type}_{sr}hz')\n", + " tr.train(train_dataloader=tr_dl, val_dataloader=vl_dl,\n", + " epochs=ABLATION_EPOCHS, optimizer_params={'lr': ABLATION_LR},\n", + " weight_decay=1e-4, monitor='roc_auc_macro',\n", + " monitor_criterion='max', load_best_model_at_last=True)\n", + " sc = tr.evaluate(te_dl)\n", + " scores[model_name] = sc\n", + " print(f' ROC-AUC={sc[\"roc_auc_macro\"]:.4f} F1={sc[\"f1_macro\"]:.4f}')\n", + " return scores\n", + "\n", + "\n", + "print(\"Label definitions sourced from ptbxl_multilabel_classification.py:\")\n", + "print(f\" SUPERDIAG_CLASSES : {SUPERDIAG_CLASSES}\")\n", + "print(f\" CHALLENGE_SNOMED_CLASSES : {len(CHALLENGE_SNOMED_CLASSES)} codes (27-class Challenge vocab)\")\n", + "print(f\" SNOMED_TO_SUPERDIAG : {len(SNOMED_TO_SUPERDIAG)} entries\")\n", + "print(f\"\\nrun_config OK (ABLATION_EPOCHS={ABLATION_EPOCHS}, ABLATION_SAMPLES={ABLATION_SAMPLES})\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baba342d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + " Config: superdiagnostic/100Hz\n", + "============================================================\n", + " Dataset: 2,000 samples | 5 classes | signal (12, 1000)\n", + " >>> SparcNet ...\n", + "\n", + "=== Input data statistics ===\n", + "n_channels: 12\n", + "length: 1000\n", + "SparcNet(\n", + " (encoder): Sequential(\n", + " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", + " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu0): ELU(alpha=1.0)\n", + " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (denseblock1): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition1): TransitionLayer(\n", + " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock2): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition2): TransitionLayer(\n", + " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock3): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition3): TransitionLayer(\n", + " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock4): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition4): TransitionLayer(\n", + " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock5): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition5): TransitionLayer(\n", + " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock6): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition6): TransitionLayer(\n", + " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock7): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition7): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " )\n", + " (fc): Linear(in_features=63, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:20<00:00, 2.40it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.6054\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.78it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.5230\n", + "f1_macro: 0.2900\n", + "loss: 0.5610\n", + "New best roc_auc_macro score (0.5230) at epoch-0, step-50\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:23<00:00, 2.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5625\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.4944\n", + "f1_macro: 0.2900\n", + "loss: 0.5665\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.31it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5604\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.69it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.5414\n", + "f1_macro: 0.3885\n", + "loss: 0.5585\n", + "New best roc_auc_macro score (0.5414) at epoch-2, step-150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.53it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=0.4783 F1=0.3842\n", + " >>> BiLSTMECG ...\n", + "BiLSTMECG(\n", + " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", + " (pool): AdaptiveAvgPool1d(output_size=1)\n", + " (fc): Linear(in_features=128, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.58it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.5954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.84it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.5183\n", + "f1_macro: 0.3915\n", + "loss: 0.5586\n", + "New best roc_auc_macro score (0.5183) at epoch-0, step-50\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.50it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5513\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.96it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.5181\n", + "f1_macro: 0.3915\n", + "loss: 0.5578\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.62it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5507\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.94it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.5196\n", + "f1_macro: 0.3915\n", + "loss: 0.5582\n", + "New best roc_auc_macro score (0.5196) at epoch-2, step-150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.88it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=0.4832 F1=0.3864\n", + "\n", + "============================================================\n", + " Config: diagnostic/100Hz\n", + "============================================================\n", + " Dataset: 2,000 samples | 26 classes | signal (12, 1000)\n", + " >>> SparcNet ...\n", + "\n", + "=== Input data statistics ===\n", + "n_channels: 12\n", + "length: 1000\n", + "SparcNet(\n", + " (encoder): Sequential(\n", + " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", + " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu0): ELU(alpha=1.0)\n", + " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (denseblock1): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition1): TransitionLayer(\n", + " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock2): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition2): TransitionLayer(\n", + " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock3): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition3): TransitionLayer(\n", + " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock4): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition4): TransitionLayer(\n", + " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock5): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition5): TransitionLayer(\n", + " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock6): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition6): TransitionLayer(\n", + " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock7): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition7): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " )\n", + " (fc): Linear(in_features=63, out_features=21, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.30it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.3159\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.55it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.2205\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:22<00:00, 2.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.1308\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.64it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1810\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.28it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.1291\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.62it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1679\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.57it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=nan F1=0.0433\n", + " >>> BiLSTMECG ...\n", + "BiLSTMECG(\n", + " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", + " (pool): AdaptiveAvgPool1d(output_size=1)\n", + " (fc): Linear(in_features=128, out_features=21, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.60it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.3631\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.89it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1658\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.48it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.1270\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.90it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1587\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.57it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.1259\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.88it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1599\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 17.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=nan F1=0.0433\n", + "\n", + "============================================================\n", + " Config: superdiagnostic/500Hz\n", + "============================================================\n", + " Dataset: 2,000 samples | 5 classes | signal (12, 5000)\n", + " >>> SparcNet ...\n", + "\n", + "=== Input data statistics ===\n", + "n_channels: 12\n", + "length: 5000\n", + "SparcNet(\n", + " (encoder): Sequential(\n", + " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", + " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu0): ELU(alpha=1.0)\n", + " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (denseblock1): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition1): TransitionLayer(\n", + " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock2): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition2): TransitionLayer(\n", + " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock3): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition3): TransitionLayer(\n", + " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock4): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition4): TransitionLayer(\n", + " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock5): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition5): TransitionLayer(\n", + " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock6): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition6): TransitionLayer(\n", + " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock7): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition7): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock8): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition8): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock9): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition9): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock10): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition10): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " )\n", + " (fc): Linear(in_features=63, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:43<00:00, 2.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.5991\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.4982\n", + "f1_macro: 0.3926\n", + "loss: 0.5812\n", + "New best roc_auc_macro score (0.4982) at epoch-0, step-50\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:38<00:00, 1.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5634\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:10<00:00, 1.49s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.5160\n", + "f1_macro: 0.2900\n", + "loss: 0.5975\n", + "New best roc_auc_macro score (0.5160) at epoch-1, step-100\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:40<00:00, 2.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5615\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.5322\n", + "f1_macro: 0.2900\n", + "loss: 0.6054\n", + "New best roc_auc_macro score (0.5322) at epoch-2, step-150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=0.5044 F1=0.2882\n", + " >>> BiLSTMECG ...\n", + "BiLSTMECG(\n", + " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", + " (pool): AdaptiveAvgPool1d(output_size=1)\n", + " (fc): Linear(in_features=128, out_features=5, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:41<00:00, 1.20it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.5999\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: 0.4649\n", + "f1_macro: 0.3915\n", + "loss: 0.5612\n", + "New best roc_auc_macro score (0.4649) at epoch-0, step-50\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.5507\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: 0.4619\n", + "f1_macro: 0.3915\n", + "loss: 0.5593\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:40<00:00, 1.23it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.5505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: 0.4636\n", + "f1_macro: 0.3915\n", + "loss: 0.5572\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=0.4028 F1=0.3864\n", + "\n", + "============================================================\n", + " Config: diagnostic/500Hz\n", + "============================================================\n", + " Dataset: 2,000 samples | 26 classes | signal (12, 5000)\n", + " >>> SparcNet ...\n", + "\n", + "=== Input data statistics ===\n", + "n_channels: 12\n", + "length: 5000\n", + "SparcNet(\n", + " (encoder): Sequential(\n", + " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", + " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu0): ELU(alpha=1.0)\n", + " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (denseblock1): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition1): TransitionLayer(\n", + " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock2): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition2): TransitionLayer(\n", + " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock3): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition3): TransitionLayer(\n", + " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock4): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition4): TransitionLayer(\n", + " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock5): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition5): TransitionLayer(\n", + " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock6): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition6): TransitionLayer(\n", + " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock7): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition7): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock8): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition8): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock9): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition9): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " (denseblock10): DenseBlock(\n", + " (denselayer1): DenseLayer(\n", + " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer2): DenseLayer(\n", + " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer3): DenseLayer(\n", + " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " (denselayer4): DenseLayer(\n", + " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu1): ELU(alpha=1.0)\n", + " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", + " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu2): ELU(alpha=1.0)\n", + " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", + " )\n", + " )\n", + " (transition10): TransitionLayer(\n", + " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (elu): ELU(alpha=1.0)\n", + " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", + " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", + " )\n", + " )\n", + " (fc): Linear(in_features=63, out_features=21, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:41<00:00, 2.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.3514\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1880\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:44<00:00, 2.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.1310\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1611\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:40<00:00, 2.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-2, step-150 ---\n", + "loss: 0.1288\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-2, step-150 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1610\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ROC-AUC=nan F1=0.0433\n", + " >>> BiLSTMECG ...\n", + "BiLSTMECG(\n", + " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", + " (pool): AdaptiveAvgPool1d(output_size=1)\n", + " (fc): Linear(in_features=128, out_features=21, bias=True)\n", + ")\n", + "Metrics: ['roc_auc_macro', 'f1_macro']\n", + "Device: cpu\n", + "\n", + "Training:\n", + "Batch size: 32\n", + "Optimizer: \n", + "Optimizer params: {'lr': 0.001}\n", + "Weight decay: 0.0001\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Monitor: roc_auc_macro\n", + "Monitor criterion: max\n", + "Epochs: 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.26it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-0, step-50 ---\n", + "loss: 0.3763\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.74it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-0, step-50 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1656\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.26it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Train epoch-1, step-100 ---\n", + "loss: 0.1266\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.48it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Eval epoch-1, step-100 ---\n", + "roc_auc_macro: nan\n", + "f1_macro: 0.0417\n", + "loss: 0.1593\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Epoch 2 / 3: 48%|\u2588\u2588\u2588\u2588\u258a | 24/50 [00:19<00:20, 1.25it/s]" + ] + } + ], + "source": [ + "# \u2500\u2500 Run all 8 configurations \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# 4 (label_type \u00d7 sampling_rate) \u00d7 2 models = 8 runs total.\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "CONFIGS = [\n", + " (\"superdiagnostic\", 100),\n", + " (\"diagnostic\", 100),\n", + " (\"superdiagnostic\", 500),\n", + " (\"diagnostic\", 500),\n", + "]\n", + "\n", + "ablation_results = {}\n", + "\n", + "for label_type, sr in CONFIGS:\n", + " cfg_key = f\"{label_type}/{sr}Hz\"\n", + " print(f\"\\n{'='*60}\")\n", + " print(f\" Config: {cfg_key}\")\n", + " print(f\"{'='*60}\")\n", + " try:\n", + " model_scores = run_config(label_type, sr) # returns {model_name: scores}\n", + " ablation_results[cfg_key] = model_scores\n", + " except Exception as e:\n", + " import traceback\n", + " print(f\" ERROR: {e}\")\n", + " traceback.print_exc()\n", + " ablation_results[cfg_key] = {}\n", + "\n", + "print(\"\\n\u2705 Ablation grid complete.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f9c41f3", + "metadata": {}, + "outputs": [], + "source": [ + "# \u2500\u2500 Results table + bar chart \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "rows = []\n", + "for label_type, sr in CONFIGS:\n", + " cfg_key = f\"{label_type}/{sr}Hz\"\n", + " for model_name in [\"SparcNet\", \"BiLSTMECG\"]:\n", + " res = ablation_results.get(cfg_key, {}).get(model_name, {})\n", + " rows.append({\n", + " \"label_type\": label_type,\n", + " \"sampling_rate\": f\"{sr} Hz\",\n", + " \"n_classes\": 5 if label_type == \"superdiagnostic\" else 27,\n", + " \"model\": model_name,\n", + " \"roc_auc_macro\": res.get(\"roc_auc_macro\", float(\"nan\")),\n", + " \"f1_macro\": res.get(\"f1_macro\", float(\"nan\")),\n", + " })\n", + "\n", + "df_abl = pd.DataFrame(rows)\n", + "print(\"\\n=== Ablation Results ===\")\n", + "print(df_abl.to_string(index=False, float_format=\"{:.4f}\".format))\n", + "\n", + "# Bar chart: grouped by config, split by model\n", + "configs_labels = [f\"{lt}\\n{sr}Hz\" for lt, sr in CONFIGS]\n", + "x = range(len(CONFIGS))\n", + "w = 0.35\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5))\n", + "fig.suptitle(\"Ablation: SparcNet vs BiLSTMECG\\nLabel granularity \u00d7 Temporal resolution\", fontsize=12)\n", + "\n", + "for ax, metric, title in [\n", + " (ax1, \"roc_auc_macro\", \"Macro ROC-AUC\"),\n", + " (ax2, \"f1_macro\", \"Macro F1 (thr=0.5)\"),\n", + "]:\n", + " sn_vals = [ablation_results.get(f\"{lt}/{sr}Hz\", {}).get(\"SparcNet\", {}).get(metric, float(\"nan\"))\n", + " for lt, sr in CONFIGS]\n", + " bl_vals = [ablation_results.get(f\"{lt}/{sr}Hz\", {}).get(\"BiLSTMECG\", {}).get(metric, float(\"nan\"))\n", + " for lt, sr in CONFIGS]\n", + "\n", + " ax.bar([xi - w/2 for xi in x], sn_vals, width=w, label=\"SparcNet\", color=\"#2196F3\")\n", + " ax.bar([xi + w/2 for xi in x], bl_vals, width=w, label=\"BiLSTMECG\", color=\"#FF5722\")\n", + " ax.set_xticks(list(x)); ax.set_xticklabels(configs_labels, fontsize=8)\n", + " ax.set_ylim(0, 1); ax.set_ylabel(title); ax.set_title(title)\n", + " if metric == \"roc_auc_macro\":\n", + " ax.axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=0.8, label=\"Random baseline\")\n", + " ax.legend(fontsize=8)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"ptbxl_ablation_grid.png\", dpi=150, bbox_inches=\"tight\")\n", + "plt.show()\n", + "print(\"Figure saved \u2192 ptbxl_ablation_grid.png\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "23aa34ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=======================================================\n", + " REPRODUCIBILITY CHECKLIST\n", + "=======================================================\n", + " Python : 3.9.6\n", + " PyTorch : 2.8.0\n", + " NumPy : 1.26.4\n", + " scikit-learn : 1.6.1\n", + " pandas : 2.3.3\n", + "-------------------------------------------------------\n", + " Random seed : 42 (passed to split_by_patient + model init)\n", + " Window length : 1250 samples (2.5 s \u00d7 500 Hz)\n", + " Overlap : 50% (stride = 625 samples)\n", + " Num classes : 5 (NORM, CD, HYP, MI, STTC)\n", + " Loss : BCEWithLogitsLoss (multi-label)\n", + " Optimizer : Adam (lr=1e-3)\n", + " Batch size : 32\n", + " Early stop : patience=3, monitor=val_roc_auc_macro\n", + "=======================================================\n", + "\n", + "\u2705 This notebook is self-contained and runnable on any machine.\n", + " Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\n", + " Set PTBXL_ROOT in cell 3 and re-run all cells.\n" + ] + } + ], + "source": [ + "# \u2500\u2500 STEP 12c: Reproducibility check \u2014 print all environment versions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "\n", + "import sys, torch, numpy, sklearn, pandas\n", + "\n", + "print(\"=\" * 55)\n", + "print(\" REPRODUCIBILITY CHECKLIST\")\n", + "print(\"=\" * 55)\n", + "print(f\" Python : {sys.version.split()[0]}\")\n", + "print(f\" PyTorch : {torch.__version__}\")\n", + "print(f\" NumPy : {numpy.__version__}\")\n", + "print(f\" scikit-learn : {sklearn.__version__}\")\n", + "print(f\" pandas : {pandas.__version__}\")\n", + "print(\"-\" * 55)\n", "print(f\" Random seed : 42 (passed to split_by_patient + model init)\")\n", - "print(f\" Window length : 1250 samples (2.5 s × 500 Hz)\")\n", + "print(f\" Window length : 1250 samples (2.5 s \u00d7 500 Hz)\")\n", "print(f\" Overlap : 50% (stride = 625 samples)\")\n", "print(f\" Num classes : 5 (NORM, CD, HYP, MI, STTC)\")\n", "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", @@ -3060,7 +5748,7 @@ "print(f\" Batch size : 32\")\n", "print(f\" Early stop : patience=3, monitor=val_roc_auc_macro\")\n", "print(\"=\" * 55)\n", - "print(\"\\n✅ This notebook is self-contained and runnable on any machine.\")\n", + "print(\"\\n\u2705 This notebook is self-contained and runnable on any machine.\")\n", "print(\" Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\")\n", "print(\" Set PTBXL_ROOT in cell 3 and re-run all cells.\")" ] @@ -3071,7 +5759,7 @@ "metadata": {}, "source": [ "---\n", - "## Section 13 — Graph Convolutional Network (GCN) Layer\n", + "## Section 13 \u2014 Graph Convolutional Network (GCN) Layer\n", "\n", "A GCN layer generalises convolution to irregular graph-structured data. \n", "For ECG this is useful because the 12 leads can be treated as a **graph of electrodes**,\n", @@ -3084,9 +5772,9 @@ "| Symbol | Shape | Meaning |\n", "|---|---|---|\n", "| $A$ | $N \\times N$ | Adjacency matrix (given as `edge_index`) |\n", - "| $\\hat{A} = A + I$ | $N \\times N$ | Adjacency **with self-loop** — every node aggregates its own features too |\n", + "| $\\hat{A} = A + I$ | $N \\times N$ | Adjacency **with self-loop** \u2014 every node aggregates its own features too |\n", "| $\\hat{D}_{ii} = \\sum_j \\hat{A}_{ij}$ | $N \\times N$ diagonal | Degree matrix of $\\hat{A}$ |\n", - "| $\\hat{D}^{-1/2}$ | $N \\times N$ diagonal | Symmetric normalisation — prevents scale explosion in dense graphs |\n", + "| $\\hat{D}^{-1/2}$ | $N \\times N$ diagonal | Symmetric normalisation \u2014 prevents scale explosion in dense graphs |\n", "| $X$ | $N \\times D_{in}$ | Input node feature matrix |\n", "| $\\Theta$ | $D_{in} \\times D_{out}$ | Learnable weight matrix |\n", "| $X'$ | $N \\times D_{out}$ | Output node features |\n", @@ -3095,36 +5783,36 @@ "\n", "Without normalisation, nodes with high degree would dominate aggregation. \n", "$\\hat{D}^{-1/2}\\hat{A}\\hat{D}^{-1/2}$ divides each edge weight $\\hat{A}_{ij}$ by $\\sqrt{d_i \\cdot d_j}$,\n", - "so high-degree nodes contribute proportionally less — analogous to mean aggregation.\n", + "so high-degree nodes contribute proportionally less \u2014 analogous to mean aggregation.\n", "\n", "### Step-by-step implementation\n", "\n", "```\n", - "edge_index (2, E) — pairs of connected node indices\n", - " │\n", - " ▼\n", - "Step 1: Build A ∈ R^(N×N) [scatter 1s at (src, dst) positions]\n", - " │\n", - " ▼\n", - "Step 2:  = A + I [add identity → self-loop]\n", - " │\n", - " ▼\n", - "Step 3: d̂ = Â.sum(dim=1) [row sums = node degrees]\n", - " │ D̂ = diag(d̂)\n", - " ▼\n", - "Step 4: D̂^(-1/2) = diag(d̂^(-0.5))\n", - " │\n", - " ▼\n", - "Step 5: norm_adj = D̂^(-1/2)  D̂^(-1/2) [2 matrix multiplications]\n", - " │\n", - " ▼\n", - "Step 6: X' = norm_adj @ X @ Θ [2 more matrix multiplications]\n", + "edge_index (2, E) \u2014 pairs of connected node indices\n", + " \u2502\n", + " \u25bc\n", + "Step 1: Build A \u2208 R^(N\u00d7N) [scatter 1s at (src, dst) positions]\n", + " \u2502\n", + " \u25bc\n", + "Step 2: \u00c2 = A + I [add identity \u2192 self-loop]\n", + " \u2502\n", + " \u25bc\n", + "Step 3: d\u0302 = \u00c2.sum(dim=1) [row sums = node degrees]\n", + " \u2502 D\u0302 = diag(d\u0302)\n", + " \u25bc\n", + "Step 4: D\u0302^(-1/2) = diag(d\u0302^(-0.5))\n", + " \u2502\n", + " \u25bc\n", + "Step 5: norm_adj = D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) [2 matrix multiplications]\n", + " \u2502\n", + " \u25bc\n", + "Step 6: X' = norm_adj @ X @ \u0398 [2 more matrix multiplications]\n", "```" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 32, "id": "8788cd11", "metadata": {}, "outputs": [], @@ -3139,26 +5827,26 @@ " Graph Convolutional Network layer (Kipf & Welling, ICLR 2017).\n", "\n", " Computes:\n", - " X' = D̂^(-1/2)  D̂^(-1/2) X Θ\n", + " X' = D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) X \u0398\n", "\n", " where:\n", - "  = A + I (adjacency with self-loop)\n", - " D̂ = diag( @ 1) (diagonal degree matrix of Â)\n", - " Θ ∈ R^(in_channels × out_channels) (learnable weight)\n", + " \u00c2 = A + I (adjacency with self-loop)\n", + " D\u0302 = diag(\u00c2 @ 1) (diagonal degree matrix of \u00c2)\n", + " \u0398 \u2208 R^(in_channels \u00d7 out_channels) (learnable weight)\n", "\n", " Parameters\n", " ----------\n", - " in_channels : int D_in — input feature dimension per node\n", - " out_channels : int D_out — output feature dimension per node\n", + " in_channels : int D_in \u2014 input feature dimension per node\n", + " out_channels : int D_out \u2014 output feature dimension per node\n", " \"\"\"\n", "\n", " def __init__(self, in_channels: int, out_channels: int):\n", " super(GCNConv, self).__init__()\n", "\n", - " # Learnable weight matrix Θ ∈ R^(D_in × D_out)\n", + " # Learnable weight matrix \u0398 \u2208 R^(D_in \u00d7 D_out)\n", " self.theta = nn.Parameter(torch.FloatTensor(in_channels, out_channels))\n", "\n", - " # Initialise Θ with uniform distribution scaled by 1/√D_out\n", + " # Initialise \u0398 with uniform distribution scaled by 1/\u221aD_out\n", " # (same as PyTorch's default Linear initialisation)\n", " stdv = 1.0 / math.sqrt(out_channels)\n", " self.theta.data.uniform_(-stdv, stdv)\n", @@ -3171,8 +5859,8 @@ " Node feature matrix.\n", " edge_index : torch.Tensor shape (2, E)\n", " Graph edges in COO format:\n", - " edge_index[0] — source node indices\n", - " edge_index[1] — destination node indices\n", + " edge_index[0] \u2014 source node indices\n", + " edge_index[1] \u2014 destination node indices\n", "\n", " Returns\n", " -------\n", @@ -3180,27 +5868,27 @@ " \"\"\"\n", " N = x.size(0) # number of nodes\n", "\n", - " # ── Step 1: Build sparse adjacency matrix A from edge_index ──────────\n", - " # A[src, dst] = 1 for every edge (src → dst) in edge_index\n", + " # \u2500\u2500 Step 1: Build sparse adjacency matrix A from edge_index \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + " # A[src, dst] = 1 for every edge (src \u2192 dst) in edge_index\n", " A = torch.zeros(N, N, dtype=x.dtype, device=x.device)\n", " A[edge_index[0], edge_index[1]] = 1.0\n", "\n", - " # ── Step 2: Add self-loop →  = A + I ──────────────────────────────\n", + " # \u2500\u2500 Step 2: Add self-loop \u2192 \u00c2 = A + I \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " # Ensures every node aggregates its own features in addition to neighbours\n", " A_hat = A + torch.eye(N, dtype=x.dtype, device=x.device)\n", "\n", - " # ── Step 3: Diagonal degree matrix D̂_ii = Σ_j Â_ij ─────────────────\n", - " # Row-sum of  gives the degree of each node (including self-loop)\n", - " d_hat = A_hat.sum(dim=1) # (N,) — degree vector\n", + " # \u2500\u2500 Step 3: Diagonal degree matrix D\u0302_ii = \u03a3_j \u00c2_ij \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + " # Row-sum of \u00c2 gives the degree of each node (including self-loop)\n", + " d_hat = A_hat.sum(dim=1) # (N,) \u2014 degree vector\n", " D_hat_inv_sqrt = torch.diag(d_hat.pow(-0.5)) # (N, N) diagonal matrix\n", "\n", - " # ── Step 4: Symmetric normalisation D̂^(-1/2)  D̂^(-1/2) ───────────\n", + " # \u2500\u2500 Step 4: Symmetric normalisation D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " # Each edge weight A_hat[i,j] is divided by sqrt(d_i) * sqrt(d_j)\n", " norm_adj = torch.mm(torch.mm(D_hat_inv_sqrt, A_hat), D_hat_inv_sqrt) # (N, N)\n", "\n", - " # ── Step 5: Graph convolution X' = norm_adj X Θ ───────────────────\n", - " # First multiply normalised adjacency × features: (N,N) @ (N,D_in) → (N,D_in)\n", - " # Then project through Θ: (N,D_in) @ (D_in,D_out) → (N,D_out)\n", + " # \u2500\u2500 Step 5: Graph convolution X' = norm_adj X \u0398 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + " # First multiply normalised adjacency \u00d7 features: (N,N) @ (N,D_in) \u2192 (N,D_in)\n", + " # Then project through \u0398: (N,D_in) @ (D_in,D_out) \u2192 (N,D_out)\n", " x_prime = torch.mm(torch.mm(norm_adj, x), self.theta) # (N, D_out)\n", "\n", " return x_prime" @@ -3208,7 +5896,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 33, "id": "88926470", "metadata": {}, "outputs": [ @@ -3229,34 +5917,34 @@ " [1, 0, 1],\n", " [0, 1, 0]], dtype=torch.int32)\n", "\n", - " = A + I:\n", + "\u00c2 = A + I:\n", " tensor([[1, 1, 0],\n", " [1, 1, 1],\n", " [0, 1, 1]], dtype=torch.int32)\n", "\n", - "Degree vector d̂ = Â.sum(dim=1): tensor([2., 3., 2.])\n", - " (node 0 has 2 neighbours + self → d̂[0]=2,\n", - " node 1 has 3 neighbours + self → d̂[1]=3, etc.)\n", + "Degree vector d\u0302 = \u00c2.sum(dim=1): tensor([2., 3., 2.])\n", + " (node 0 has 2 neighbours + self \u2192 d\u0302[0]=2,\n", + " node 1 has 3 neighbours + self \u2192 d\u0302[1]=3, etc.)\n", "\n", - "D̂^(-1/2) diagonal: [0.7071067690849304, 0.5773502588272095, 0.7071067690849304]\n", + "D\u0302^(-1/2) diagonal: [0.7071067690849304, 0.5773502588272095, 0.7071067690849304]\n", "\n", - "Normalised adjacency D̂^(-1/2)  D̂^(-1/2):\n", + "Normalised adjacency D\u0302^(-1/2) \u00c2 D\u0302^(-1/2):\n", " tensor([[0.5000, 0.4082, 0.0000],\n", " [0.4082, 0.3333, 0.4082],\n", " [0.0000, 0.4082, 0.5000]])\n", "\n", - "✅ GCNConv forward pass verified.\n", + "\u2705 GCNConv forward pass verified.\n", " Output shape (N, D_out) = (3, 2)\n" ] } ], "source": [ - "# ── Verify the implementation with a concrete worked example ─────────────────\n", + "# \u2500\u2500 Verify the implementation with a concrete worked example \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "#\n", - "# Graph: 3 nodes (0, 1, 2), edges: 0→1, 1→0, 1→2, 2→1\n", + "# Graph: 3 nodes (0, 1, 2), edges: 0\u21921, 1\u21920, 1\u21922, 2\u21921\n", "# 0\n", "# / \\\n", - "# 1 — 2\n", + "# 1 \u2014 2\n", "\n", "torch.manual_seed(0)\n", "\n", @@ -3264,12 +5952,12 @@ "D_in = 4 # input feature dim\n", "D_out = 2 # output feature dim\n", "\n", - "# Node features X ∈ R^(3 × 4)\n", + "# Node features X \u2208 R^(3 \u00d7 4)\n", "x_test = torch.tensor([[1., 0., 0., 0.],\n", " [0., 1., 0., 0.],\n", " [0., 0., 1., 0.]], dtype=torch.float32)\n", "\n", - "# Edges (undirected → both directions): 0↔1, 1↔2\n", + "# Edges (undirected \u2192 both directions): 0\u21941, 1\u21942\n", "edge_index_test = torch.tensor([[0, 1, 1, 2],\n", " [1, 0, 2, 1]], dtype=torch.long)\n", "\n", @@ -3281,32 +5969,32 @@ "print(\"Output X' shape:\", x_out.shape)\n", "print(\"\\nOutput X':\\n\", x_out)\n", "\n", - "# ── Manual verification of  and D̂ to confirm correctness ──────────────────\n", + "# \u2500\u2500 Manual verification of \u00c2 and D\u0302 to confirm correctness \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "A = torch.zeros(N, N)\n", "A[edge_index_test[0], edge_index_test[1]] = 1.0\n", "A_hat = A + torch.eye(N)\n", "d_hat = A_hat.sum(dim=1)\n", "\n", "print(\"\\nAdjacency A:\\n\", A.int())\n", - "print(\"\\n = A + I:\\n\", A_hat.int())\n", - "print(\"\\nDegree vector d̂ = Â.sum(dim=1):\", d_hat)\n", - "print(\" (node 0 has 2 neighbours + self → d̂[0]=2,\")\n", - "print(\" node 1 has 3 neighbours + self → d̂[1]=3, etc.)\")\n", + "print(\"\\n\u00c2 = A + I:\\n\", A_hat.int())\n", + "print(\"\\nDegree vector d\u0302 = \u00c2.sum(dim=1):\", d_hat)\n", + "print(\" (node 0 has 2 neighbours + self \u2192 d\u0302[0]=2,\")\n", + "print(\" node 1 has 3 neighbours + self \u2192 d\u0302[1]=3, etc.)\")\n", "\n", - "print(\"\\nD̂^(-1/2) diagonal:\", d_hat.pow(-0.5).tolist())\n", + "print(\"\\nD\u0302^(-1/2) diagonal:\", d_hat.pow(-0.5).tolist())\n", "\n", "D_inv_sqrt = torch.diag(d_hat.pow(-0.5))\n", "norm_adj = torch.mm(torch.mm(D_inv_sqrt, A_hat), D_inv_sqrt)\n", - "print(\"\\nNormalised adjacency D̂^(-1/2)  D̂^(-1/2):\\n\",\n", + "print(\"\\nNormalised adjacency D\u0302^(-1/2) \u00c2 D\u0302^(-1/2):\\n\",\n", " norm_adj.round(decimals=4))\n", "\n", - "print(\"\\n✅ GCNConv forward pass verified.\")\n", + "print(\"\\n\u2705 GCNConv forward pass verified.\")\n", "print(\" Output shape (N, D_out) =\", tuple(x_out.shape))" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 34, "id": "dda95b41", "metadata": {}, "outputs": [ @@ -3322,15 +6010,15 @@ } ], "source": [ - "# ── Visualise the graph and the normalised adjacency matrix ──────────────────\n", + "# \u2500\u2500 Visualise the graph and the normalised adjacency matrix \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", - "fig.suptitle(\"GCN Layer — Worked Example (N=3 nodes, D_in=4, D_out=2)\",\n", + "fig.suptitle(\"GCN Layer \u2014 Worked Example (N=3 nodes, D_in=4, D_out=2)\",\n", " fontsize=12, fontweight=\"bold\")\n", "\n", - "# ── Panel 1: Graph structure ──────────────────────────────────────────────────\n", + "# \u2500\u2500 Panel 1: Graph structure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "ax = axes[0]\n", - "ax.set_title(\"Graph structure\\n(edges 0↔1, 1↔2)\", fontweight=\"bold\")\n", + "ax.set_title(\"Graph structure\\n(edges 0\u21941, 1\u21942)\", fontweight=\"bold\")\n", "ax.set_xlim(-0.5, 2.5); ax.set_ylim(-0.5, 1.5); ax.axis(\"off\")\n", "\n", "node_pos = {0: (0, 0), 1: (1, 1), 2: (2, 0)}\n", @@ -3341,12 +6029,12 @@ " ax.add_patch(plt.Circle((nx_,ny_), 0.18, color=\"#4a90d9\", zorder=2))\n", " ax.text(nx_, ny_, str(nid), color=\"white\", ha=\"center\", va=\"center\",\n", " fontsize=13, fontweight=\"bold\", zorder=3)\n", - "ax.text(0,-0.35,\"d̂=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", - "ax.text(1, 1.25,\"d̂=3\",ha=\"center\",fontsize=9,color=\"#555\")\n", - "ax.text(2,-0.35,\"d̂=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "ax.text(0,-0.35,\"d\u0302=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "ax.text(1, 1.25,\"d\u0302=3\",ha=\"center\",fontsize=9,color=\"#555\")\n", + "ax.text(2,-0.35,\"d\u0302=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", "\n", - "# ── Panel 2: Normalised adjacency (heatmap) ───────────────────────────────────\n", - "axes[1].set_title(\"Normalised adjacency\\nD̂⁻¹/²  D̂⁻¹/²\", fontweight=\"bold\")\n", + "# \u2500\u2500 Panel 2: Normalised adjacency (heatmap) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "axes[1].set_title(\"Normalised adjacency\\nD\u0302\u207b\u00b9/\u00b2 \u00c2 D\u0302\u207b\u00b9/\u00b2\", fontweight=\"bold\")\n", "im = axes[1].imshow(norm_adj.numpy(), cmap=\"Blues\", vmin=0, vmax=0.6)\n", "for i in range(N):\n", " for j in range(N):\n", @@ -3358,8 +6046,8 @@ "axes[1].set_yticklabels([f\"node {i}\" for i in range(N)])\n", "plt.colorbar(im, ax=axes[1])\n", "\n", - "# ── Panel 3: Input X and output X' feature vectors ───────────────────────────\n", - "axes[2].set_title(\"Feature transformation\\nX (4-dim) → X' (2-dim)\", fontweight=\"bold\")\n", + "# \u2500\u2500 Panel 3: Input X and output X' feature vectors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "axes[2].set_title(\"Feature transformation\\nX (4-dim) \u2192 X' (2-dim)\", fontweight=\"bold\")\n", "x_np = x_test.detach().numpy()\n", "xp_np = x_out.detach().numpy()\n", "\n", @@ -3386,24 +6074,24 @@ "metadata": {}, "source": [ "---\n", - "## Section A — Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", + "## Section A \u2014 Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", "\n", "### Data layout on disk (what we actually have)\n", "\n", "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", - "which packages PTB-XL records in a flat WFDB layout — **no `ptbxl_database.csv`**.\n", + "which packages PTB-XL records in a flat WFDB layout \u2014 **no `ptbxl_database.csv`**.\n", "\n", "```\n", "training/ptb-xl/\n", - "├── g1/ ← group 1 (≈1000 recordings each)\n", - "│ ├── HR00001.hea ← WFDB header: leads, fs, calibration + metadata comments\n", - "│ ├── HR00001.mat ← raw signal matrix (12 × 5000 float, 500 Hz)\n", - "│ ├── HR00002.hea\n", - "│ ├── HR00002.mat\n", - "│ └── ...\n", - "├── g2/\n", - "│ └── ...\n", - "└── g22/ ← group 22\n", + "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", + "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", + "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 raw signal matrix (12 \u00d7 5000 float, 500 Hz)\n", + "\u2502 \u251c\u2500\u2500 HR00002.hea\n", + "\u2502 \u251c\u2500\u2500 HR00002.mat\n", + "\u2502 \u2514\u2500\u2500 ...\n", + "\u251c\u2500\u2500 g2/\n", + "\u2502 \u2514\u2500\u2500 ...\n", + "\u2514\u2500\u2500 g22/ \u2190 group 22\n", "```\n", "\n", "### What a `.hea` file looks like\n", @@ -3414,7 +6102,7 @@ "... (12 lead rows)\n", "# Age: 56\n", "# Sex: Female\n", - "# Dx: 251146004,426783006 ← SNOMED-CT codes (comma-separated)\n", + "# Dx: 251146004,426783006 \u2190 SNOMED-CT codes (comma-separated)\n", "# Rx: Unknown\n", "# Hx: Unknown\n", "# Sx: Unknown\n", @@ -3441,7 +6129,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 35, "id": "55a8f37d", "metadata": {}, "outputs": [ @@ -3451,9 +6139,9 @@ "text": [ "CinC 2020 root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", "CSV exists : True (/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv)\n", - "[INFO] Cached CSV found → /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", + "[INFO] Cached CSV found \u2192 /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", "\n", - "Loaded df_meta: (21837, 10) — 21,837 ECGs × 10 columns\n" + "Loaded df_meta: (21837, 10) \u2014 21,837 ECGs \u00d7 10 columns\n" ] } ], @@ -3463,22 +6151,22 @@ "from pathlib import Path\n", "from typing import Optional\n", "\n", - "# ── Section A paths ───────────────────────────────────────────────────────────\n", + "# \u2500\u2500 Section A paths \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# CinC 2020 Challenge data: g1/ - g22/ folders with .hea/.mat files\n", "PTBXL_CHALLENGE_ROOT = Path(\n", " \"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/\"\n", " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/\"\n", " \"training/ptb-xl\"\n", ")\n", - "# Output CSV (will be cached — skip rebuild if already exists)\n", + "# Output CSV (will be cached \u2014 skip rebuild if already exists)\n", "CSV_OUTPUT_PATH = PTBXL_CHALLENGE_ROOT / \"ptbxl-pyhealth.csv\"\n", "\n", "print(f\"CinC 2020 root : {PTBXL_CHALLENGE_ROOT}\")\n", "print(f\"CSV exists : {CSV_OUTPUT_PATH.exists()} ({CSV_OUTPUT_PATH})\")\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Helper: parse a single WFDB .hea file\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def parse_hea_file(hea_path: Path) -> Optional[dict]:\n", " \"\"\"\n", " Parse one WFDB header file (.hea) and return a metadata dict.\n", @@ -3527,12 +6215,12 @@ " \"num_samples\": num_samples, \"num_leads\": num_leads, \"group\": group}\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Main builder: scan all g* directories → ptbxl-pyhealth.csv\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Main builder: scan all g* directories \u2192 ptbxl-pyhealth.csv\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def build_ptbxl_csv(root: Path, output_path: Path, force: bool = False) -> pd.DataFrame:\n", " if output_path.exists() and not force:\n", - " print(f\"[INFO] Cached CSV found → {output_path}\")\n", + " print(f\"[INFO] Cached CSV found \u2192 {output_path}\")\n", " return pd.read_csv(output_path)\n", "\n", " group_dirs = sorted(\n", @@ -3556,18 +6244,18 @@ " ])\n", " output_path.parent.mkdir(parents=True, exist_ok=True)\n", " df.to_csv(output_path, index=False)\n", - " print(f\"[DONE] {len(df):,} records | {failed} failed → {output_path}\")\n", + " print(f\"[DONE] {len(df):,} records | {failed} failed \u2192 {output_path}\")\n", " return df\n", "\n", "\n", - "# ── Run (uses cached CSV if present) ──────────────────────────────────────────\n", + "# \u2500\u2500 Run (uses cached CSV if present) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "df_meta = build_ptbxl_csv(PTBXL_CHALLENGE_ROOT, CSV_OUTPUT_PATH, force=False)\n", - "print(f\"\\nLoaded df_meta: {df_meta.shape} — {df_meta.shape[0]:,} ECGs × {df_meta.shape[1]} columns\")\n" + "print(f\"\\nLoaded df_meta: {df_meta.shape} \u2014 {df_meta.shape[0]:,} ECGs \u00d7 {df_meta.shape[1]} columns\")\n" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, "id": "ab0625a5", "metadata": {}, "outputs": [ @@ -3576,7 +6264,7 @@ "output_type": "stream", "text": [ "============================================================\n", - " PTB-XL / CinC 2020 — ptbxl-pyhealth.csv statistics\n", + " PTB-XL / CinC 2020 \u2014 ptbxl-pyhealth.csv statistics\n", "============================================================\n", " Total recordings : 21,837\n", " Groups (folders) : 22\n", @@ -3751,15 +6439,15 @@ "4 500 5000 12 g1 " ] }, - "execution_count": 29, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# ── Dataset statistics (mirrors HW5 dataset.stat() style) ────────────────────\n", + "# \u2500\u2500 Dataset statistics (mirrors HW5 dataset.stat() style) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "print(\"=\" * 60)\n", - "print(\" PTB-XL / CinC 2020 — ptbxl-pyhealth.csv statistics\")\n", + "print(\" PTB-XL / CinC 2020 \u2014 ptbxl-pyhealth.csv statistics\")\n", "print(\"=\" * 60)\n", "print(f\" Total recordings : {len(df_meta):,}\")\n", "print(f\" Groups (folders) : {df_meta['group'].nunique()}\")\n", @@ -3780,7 +6468,7 @@ " .to_string(index=False))\n", "print()\n", "\n", - "# ── Dx / SNOMED code distribution ────────────────────────────────────────────\n", + "# \u2500\u2500 Dx / SNOMED code distribution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "from collections import Counter\n", "code_counter = Counter()\n", "for codes in df_meta['scp_codes'].dropna():\n", @@ -3804,50 +6492,50 @@ "id": "efc37ea8", "metadata": {}, "source": [ - "---\n", - "## Section B — PyHealth-Compatible Dataset & Task\n", "\n", - "Following the **HW5 PyHealth pattern** (Dataset → set_task → DataLoader → Model → Train → Evaluate), \n", + "Following the **HW5 PyHealth pattern** (Dataset \u2192 set_task \u2192 DataLoader \u2192 Model \u2192 Train \u2192 Evaluate), \n", "here we show how `ptbxl-pyhealth.csv` feeds directly into a PyHealth-style pipeline.\n", "\n", "### Architecture overview\n", "\n", "```\n", - "ptbxl-pyhealth.csv (built in Section A)\n", - " │\n", - " ▼\n", - "PTBXLRecordDataset(root, csv) # Loads metadata, groups records\n", - " │\n", - " ▼ .set_task(ptbxl_multilabel_fn)\n", - "SampleDataset — list of samples # Each sample = {signal: tensor, labels: [...]}\n", - " │\n", - " ├── split_by_sample([0.7,0.1,0.2])\n", - " │ ├── train_loader (batch_size=32, shuffle=True)\n", - " │ ├── val_loader\n", - " │ └── test_loader\n", - " ▼\n", - "Your model (SparcNet / BiLSTM / Transformer)\n", - " │ trainer.train(...)\n", - " ▼\n", - "trainer.evaluate() → roc_auc_macro, f1_macro\n", + "ptbxl-pyhealth.csv (built in Section A above)\n", + " \u2502\n", + " \u25bc\n", + "PTBXLRecordDataset(root, csv) # Loads metadata, groups records by ID\n", + " \u2502\n", + " \u25bc .set_task(ptbxl_multilabel_fn)\n", + "PTBXLSampleDataset \u2014 list of samples # Each sample = {patient_id, record_id,\n", + " # signal: np.ndarray (12,T), labels: List[str],\n", + " # label_vec: np.ndarray (5,), age, sex}\n", + " \u2502\n", + " \u251c\u2500\u2500 split_by_sample((0.7, 0.1, 0.2), seed=42)\n", + " \u2502 \u251c\u2500\u2500 train_loader (15,166 samples, batch_size=32, shuffle=True)\n", + " \u2502 \u251c\u2500\u2500 val_loader ( 2,166 samples)\n", + " \u2502 \u2514\u2500\u2500 test_loader ( 4,334 samples)\n", + " \u25bc\n", + "Your model (SparcNet / BiLSTMECG)\n", + " \u2502 trainer.train(train_loader, val_loader, epochs=5)\n", + " \u25bc\n", + "trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro\n", "```\n", "\n", - "### SNOMED-CT → Superdiagnostic mapping (5 classes)\n", + "### SNOMED-CT \u2192 Superdiagnostic mapping (5 classes)\n", "\n", - "Matches the PTB-XL superdiagnostic label space used in the original paper:\n", + "A ~30-code subset defined locally in this section (distinct from the 46-code map used in Step 6):\n", "\n", "| Class | Meaning | Example SNOMED codes |\n", "|---|---|---|\n", - "| `NORM` | Normal ECG | 426783006 |\n", - "| `MI` | Myocardial infarction | 57054005, 164909002, … |\n", - "| `STTC` | ST/T-change | 428750005, 164931005, … |\n", - "| `CD` | Conduction disturbance | 270492004, 164890007, … |\n", - "| `HYP` | Hypertrophy | 164873001, 89792004, … |\n" + "| `NORM` | Normal sinus rhythm | 426783006 |\n", + "| `MI` | Myocardial infarction | 164865005, 89792004, 413444003, \u2026 |\n", + "| `STTC` | ST/T-change | 164934002, 164931005, 428750005, \u2026 |\n", + "| `CD` | Conduction disturbance | 270492004, 164889003, 445118002, \u2026 |\n", + "| `HYP` | Hypertrophy / axis deviation | 164873001, 164862005, 111975006, \u2026 |" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 37, "id": "3c137a37", "metadata": {}, "outputs": [ @@ -3867,7 +6555,7 @@ "from pathlib import Path\n", "from typing import Optional\n", "\n", - "# ── SNOMED-CT → 5-class superdiagnostic mapping ───────────────────────────────\n", + "# \u2500\u2500 SNOMED-CT \u2192 5-class superdiagnostic mapping \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Source: PTB-XL paper (Wagner et al. 2020) Supplementary Table S3\n", "SNOMED_TO_SUPERDIAG = {\n", " # NORM\n", @@ -3893,9 +6581,9 @@ "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# PyHealth-compatible Dataset (mirrors HW5's MIMIC3Dataset interface)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLRecordDataset:\n", " \"\"\"\n", " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", @@ -3908,7 +6596,7 @@ " ----------\n", " root : Path to training/ptb-xl/ (signal .mat files resolved relative here)\n", " csv : Path to ptbxl-pyhealth.csv\n", - " sampling_rate: 500 (native) or 100 (decimated 5×)\n", + " sampling_rate: 500 (native) or 100 (decimated 5\u00d7)\n", " \"\"\"\n", "\n", " def __init__(\n", @@ -3920,7 +6608,7 @@ " self.root = Path(root)\n", " self.sampling_rate = sampling_rate\n", " self._df = pd.read_csv(csv)\n", - " # Build patients dict — one \"visit\" per recording (HW5 analogy)\n", + " # Build patients dict \u2014 one \"visit\" per recording (HW5 analogy)\n", " self.patients = {\n", " row[\"patient_id\"]: row.to_dict()\n", " for _, row in self._df.iterrows()\n", @@ -3928,7 +6616,7 @@ " print(f\"[PTBXLRecordDataset] Loaded {len(self.patients):,} records \"\n", " f\"from {csv.name} @ {sampling_rate} Hz target\")\n", "\n", - " # ── stat(): mirrors HW5 dataset.stat() ───────────────────────────────────\n", + " # \u2500\u2500 stat(): mirrors HW5 dataset.stat() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " def stat(self):\n", " df = self._df\n", " print(\"=\" * 55)\n", @@ -3942,7 +6630,7 @@ " for c in str(codes).split(',')})))\n", " print(\"=\" * 55)\n", "\n", - " # ── set_task(): mirrors HW5 dataset.set_task() ────────────────────────────\n", + " # \u2500\u2500 set_task(): mirrors HW5 dataset.set_task() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " def set_task(self, task_fn) -> \"PTBXLSampleDataset\":\n", " \"\"\"Apply a task function to every record and return a SampleDataset.\"\"\"\n", " samples = []\n", @@ -3957,10 +6645,10 @@ " return PTBXLSampleDataset(samples)\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Task function: multilabel superdiagnostic classification\n", "# (mirrors HW5's mortality_prediction_mimic3_fn)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def ptbxl_multilabel_fn(record: dict, root: Path, sampling_rate: int = 100) -> Optional[dict]:\n", " \"\"\"\n", " Convert one PTB-XL record dict (a row from ptbxl-pyhealth.csv) into\n", @@ -3980,19 +6668,19 @@ " if not mat_path.exists():\n", " return None\n", "\n", - " # ── Load signal ───────────────────────────────────────────────────────────\n", + " # \u2500\u2500 Load signal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " try:\n", " mat = scipy.io.loadmat(str(mat_path))\n", - " # CinC 2020 .mat stores signal under key 'val' (shape 12×5000)\n", + " # CinC 2020 .mat stores signal under key 'val' (shape 12\u00d75000)\n", " signal = mat[\"val\"].astype(np.float32) # (12, 5000)\n", " except Exception:\n", " return None\n", "\n", - " # ── Decimate to target sampling rate ──────────────────────────────────────\n", + " # \u2500\u2500 Decimate to target sampling rate \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " if sampling_rate == 100:\n", - " signal = signal[:, ::5] # 500 Hz → 100 Hz ( stride 5 )\n", + " signal = signal[:, ::5] # 500 Hz \u2192 100 Hz ( stride 5 )\n", "\n", - " # ── Map Dx codes → superdiagnostic classes ────────────────────────────────\n", + " # \u2500\u2500 Map Dx codes \u2192 superdiagnostic classes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " scp_raw = str(record.get(\"scp_codes\", \"\"))\n", " codes = [c.strip() for c in scp_raw.split(\",\") if c.strip()]\n", " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", @@ -4000,7 +6688,7 @@ " if not labels:\n", " return None # skip records with no mappable superdiagnostic code\n", "\n", - " # ── Multi-hot label vector (matches HW5 label pattern) ───────────────────\n", + " # \u2500\u2500 Multi-hot label vector (matches HW5 label pattern) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", " for lbl in labels:\n", " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", @@ -4016,12 +6704,12 @@ " }\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# SampleDataset + DataLoader helpers\n", "# (mirrors HW5's SampleDataset / get_dataloader)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLSampleDataset(Dataset):\n", - " \"\"\"Thin wrapper around a list of sample dicts — compatible with DataLoader.\"\"\"\n", + " \"\"\"Thin wrapper around a list of sample dicts \u2014 compatible with DataLoader.\"\"\"\n", "\n", " def __init__(self, samples: list):\n", " self.samples = samples\n", @@ -4078,7 +6766,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 38, "id": "0a41c8f8", "metadata": {}, "outputs": [ @@ -4103,7 +6791,7 @@ " CD : 5999 (27.7%)\n", " HYP : 2466 (11.4%)\n", "\n", - "Splits → train: 15,166 | val: 2,166 | test: 4,334\n", + "Splits \u2192 train: 15,166 | val: 2,166 | test: 4,334\n", "Batches/epoch : 474\n", "\n", "One training batch:\n", @@ -4117,7 +6805,7 @@ } ], "source": [ - "# ── Full pipeline run (HW5-style 5 stages) ────────────────────────────────────\n", + "# \u2500\u2500 Full pipeline run (HW5-style 5 stages) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "\n", "# Stage 1: Load dataset\n", "ptbxl_ds = PTBXLRecordDataset(\n", @@ -4138,10 +6826,10 @@ "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", "\n", - "print(f\"Splits → train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}\")\n", + "print(f\"Splits \u2192 train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}\")\n", "print(f\"Batches/epoch : {len(train_loader)}\")\n", "\n", - "# ── Peek at one batch (like HW4's data verification) ─────────────────────────\n", + "# \u2500\u2500 Peek at one batch (like HW4's data verification) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "batch = next(iter(train_loader))\n", "print()\n", "print(\"One training batch:\")\n", @@ -4159,21 +6847,21 @@ "metadata": {}, "source": [ "---\n", - "## Section A — Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", + "## Section A \u2014 Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", "\n", "### Data layout on disk (what we actually have)\n", "\n", "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", - "which packages PTB-XL records in a flat WFDB layout — **no `ptbxl_database.csv`**.\n", + "which packages PTB-XL records in a flat WFDB layout \u2014 **no `ptbxl_database.csv`**.\n", "\n", "```\n", "training/ptb-xl/\n", - "├── g1/ ← group 1 (≈1000 recordings each)\n", - "│ ├── HR00001.hea ← WFDB header: leads, fs, calibration + metadata comments\n", - "│ ├── HR00001.mat ← raw signal matrix (12 × 5000 float, 500 Hz)\n", - "│ ├── HR00002.hea\n", - "│ └── ...\n", - "├── g2/ ... g22/\n", + "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", + "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", + "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 raw signal matrix (12 \u00d7 5000 float, 500 Hz)\n", + "\u2502 \u251c\u2500\u2500 HR00002.hea\n", + "\u2502 \u2514\u2500\u2500 ...\n", + "\u251c\u2500\u2500 g2/ ... g22/\n", "```\n", "\n", "### What a `.hea` header file looks like\n", @@ -4184,7 +6872,7 @@ "... (12 signal rows)\n", "# Age: 56\n", "# Sex: Female\n", - "# Dx: 251146004,426783006 ← SNOMED-CT codes, comma-separated\n", + "# Dx: 251146004,426783006 \u2190 SNOMED-CT codes, comma-separated\n", "# Rx: Unknown\n", "```\n", "\n", @@ -4209,16 +6897,16 @@ "id": "1a07dd75", "metadata": {}, "source": [ - "## 📥 Download PTB-XL 1.0.3 (Full Dataset)\n", + "## \ud83d\udce5 Download PTB-XL 1.0.3 (Full Dataset)\n", "\n", "The YAML config and Section B pipeline use the **official PTB-XL 1.0.3** dataset from PhysioNet, which includes:\n", - "- `ptbxl_database.csv` — 21,799 ECG records × 28 metadata columns\n", - "- `scp_statements.csv` — 71 SCP-ECG codes with diagnostic class mappings\n", - "- `records100/` — 100 Hz WFDB signals (`.hea` + `.dat`)\n", - "- `records500/` — 500 Hz WFDB signals (`.hea` + `.dat`)\n", + "- `ptbxl_database.csv` \u2014 21,799 ECG records \u00d7 28 metadata columns\n", + "- `scp_statements.csv` \u2014 71 SCP-ECG codes with diagnostic class mappings\n", + "- `records100/` \u2014 100 Hz WFDB signals (`.hea` + `.dat`)\n", + "- `records500/` \u2014 500 Hz WFDB signals (`.hea` + `.dat`)\n", "\n", "**Why not the Kaggle `physionet/ptbxl-electrocardiography-database`?** \n", - "That Kaggle dataset contains only WFDB `.hea`/`.mat` files (CinC 2020 challenge format) — **no** `ptbxl_database.csv`. \n", + "That Kaggle dataset contains only WFDB `.hea`/`.mat` files (CinC 2020 challenge format) \u2014 **no** `ptbxl_database.csv`. \n", "For the full metadata, use: `garethwmch/ptb-xl-1-0-3` (87k files, CC0 license).\n", "\n", "**Download options (run the cell below):**\n" @@ -4226,7 +6914,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 39, "id": "c0a20bba", "metadata": {}, "outputs": [ @@ -4236,28 +6924,28 @@ "text": [ "PTB-XL asset audit\n", "============================================================\n", - " ptbxl_database.csv : ✅ 6440 KB\n", - " scp_statements.csv : ✅ 9 KB\n", - " WFDB/ signals : ✅ 21,837 .mat files (500 Hz)\n", - " records100/ (100Hz): ❌ not present — using WFDB/ flat folder instead\n", - " records500/ (500Hz): ❌ not present — using WFDB/ flat folder instead\n", + " ptbxl_database.csv : \u2705 6440 KB\n", + " scp_statements.csv : \u2705 9 KB\n", + " WFDB/ signals : \u2705 21,837 .mat files (500 Hz)\n", + " records100/ (100Hz): \u274c not present \u2014 using WFDB/ flat folder instead\n", + " records500/ (500Hz): \u274c not present \u2014 using WFDB/ flat folder instead\n", "\n", - "✅ All required data present — proceed to Section B!\n", + "\u2705 All required data present \u2014 proceed to Section B!\n", "\n", " Data layout:\n", - " • Metadata CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/ptbxl_database.csv\n", - " • SCP codes : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/scp_statements.csv\n", - " • Signal files : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/WFDB/HR{ecg_id:05d}.mat (500 Hz, 12-lead)\n", + " \u2022 Metadata CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/ptbxl_database.csv\n", + " \u2022 SCP codes : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/scp_statements.csv\n", + " \u2022 Signal files : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/WFDB/HR{ecg_id:05d}.mat (500 Hz, 12-lead)\n", "\n", " NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\n", - " The WFDB/ .mat files are the same PTB-XL signals — just flat layout.\n" + " The WFDB/ .mat files are the same PTB-XL signals \u2014 just flat layout.\n" ] } ], "source": [ "from pathlib import Path\n", "\n", - "# ── Locate PTB-XL assets ──────────────────────────────────────────────────────\n", + "# \u2500\u2500 Locate PTB-XL assets \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\"\n", "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\"\n", @@ -4265,47 +6953,47 @@ "\n", "print(\"PTB-XL asset audit\")\n", "print(\"=\" * 60)\n", - "print(f\" ptbxl_database.csv : {'✅ ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '❌ not found'}\")\n", - "print(f\" scp_statements.csv : {'✅ ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '❌ not found'}\")\n", + "print(f\" ptbxl_database.csv : {'\u2705 ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '\u274c not found'}\")\n", + "print(f\" scp_statements.csv : {'\u2705 ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '\u274c not found'}\")\n", "\n", "if WFDB_ROOT.is_dir():\n", " n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\"))\n", - " print(f\" WFDB/ signals : ✅ {n_mat:,} .mat files (500 Hz)\")\n", + " print(f\" WFDB/ signals : \u2705 {n_mat:,} .mat files (500 Hz)\")\n", "else:\n", - " print(f\" WFDB/ signals : ❌ not found at {WFDB_ROOT}\")\n", + " print(f\" WFDB/ signals : \u274c not found at {WFDB_ROOT}\")\n", "\n", "records100 = PROJECT_ROOT / \"records100\"\n", "records500 = PROJECT_ROOT / \"records500\"\n", - "print(f\" records100/ (100Hz): {'✅' if records100.is_dir() else '❌ not present — using WFDB/ flat folder instead'}\")\n", - "print(f\" records500/ (500Hz): {'✅' if records500.is_dir() else '❌ not present — using WFDB/ flat folder instead'}\")\n", + "print(f\" records100/ (100Hz): {'\u2705' if records100.is_dir() else '\u274c not present \u2014 using WFDB/ flat folder instead'}\")\n", + "print(f\" records500/ (500Hz): {'\u2705' if records500.is_dir() else '\u274c not present \u2014 using WFDB/ flat folder instead'}\")\n", "\n", "print()\n", "if PTBXL_DATABASE_CSV.exists() and WFDB_ROOT.is_dir():\n", - " print(\"✅ All required data present — proceed to Section B!\")\n", + " print(\"\u2705 All required data present \u2014 proceed to Section B!\")\n", " print()\n", " print(\" Data layout:\")\n", - " print(f\" • Metadata CSV : {PTBXL_DATABASE_CSV}\")\n", - " print(f\" • SCP codes : {SCP_STATEMENTS_CSV}\")\n", - " print(f\" • Signal files : {WFDB_ROOT}/HR{{ecg_id:05d}}.mat (500 Hz, 12-lead)\")\n", + " print(f\" \u2022 Metadata CSV : {PTBXL_DATABASE_CSV}\")\n", + " print(f\" \u2022 SCP codes : {SCP_STATEMENTS_CSV}\")\n", + " print(f\" \u2022 Signal files : {WFDB_ROOT}/HR{{ecg_id:05d}}.mat (500 Hz, 12-lead)\")\n", " print()\n", " print(\" NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\")\n", - " print(\" The WFDB/ .mat files are the same PTB-XL signals — just flat layout.\")\n", + " print(\" The WFDB/ .mat files are the same PTB-XL signals \u2014 just flat layout.\")\n", "else:\n", - " print(\"⚠️ Missing required files. Download options:\")\n", + " print(\"\u26a0\ufe0f Missing required files. Download options:\")\n", " print()\n", - " print(\"── Option A: CSVs only from PhysioNet (no account, ~5 MB) ────────────\")\n", + " print(\"\u2500\u2500 Option A: CSVs only from PhysioNet (no account, ~5 MB) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\")\n", " print(f\" cd {PROJECT_ROOT}\")\n", " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/ptbxl_database.csv\")\n", " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/scp_statements.csv\")\n", " print()\n", - " print(\"── Option B: Full dataset incl. records100/500 (~3.2 GB, Kaggle) ─────\")\n", + " print(\"\u2500\u2500 Option B: Full dataset incl. records100/500 (~3.2 GB, Kaggle) \u2500\u2500\u2500\u2500\u2500\")\n", " print(\" kaggle datasets download -d garethwmch/ptb-xl-1-0-3 --unzip \\\\\")\n", " print(f\" -p \\\"{PROJECT_ROOT}\\\"\")\n" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 40, "id": "b406bc94", "metadata": {}, "outputs": [ @@ -4313,38 +7001,38 @@ "name": "stdout", "output_type": "stream", "text": [ - "ptbxl_database.csv : ✅ 6440 KB\n", - "scp_statements.csv : ✅ 9 KB\n", - "WFDB/ signals : ✅ 21837 .mat files\n", - "Signal FS : 500 Hz → T=5000 samples per recording\n" + "ptbxl_database.csv : \u2705 6440 KB\n", + "scp_statements.csv : \u2705 9 KB\n", + "WFDB/ signals : \u2705 21837 .mat files\n", + "Signal FS : 500 Hz \u2192 T=5000 samples per recording\n" ] } ], "source": [ "from pathlib import Path\n", "\n", - "# ── PTB-XL paths (CSVs at project root; signals in WFDB/ flat .mat folder) ────\n", + "# \u2500\u2500 PTB-XL paths (CSVs at project root; signals in WFDB/ flat .mat folder) \u2500\u2500\u2500\u2500\n", "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", "\n", - "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\" # 21,799 rows × 28 cols\n", + "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\" # 21,799 rows \u00d7 28 cols\n", "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\" # 71 SCP-ECG codes\n", "WFDB_ROOT = PROJECT_ROOT / \"WFDB\" # HR00001.mat - HR21837.mat\n", "RECORDS_CSV = PROJECT_ROOT / \"ptbxl-records-pyhealth.csv\" # auto-generated below\n", "\n", "# Signal files are 500 Hz, channel-first (12, 5000)\n", - "# ecg_id → WFDB/HR{ecg_id:05d}.mat\n", + "# ecg_id \u2192 WFDB/HR{ecg_id:05d}.mat\n", "SIGNAL_FS = 500 # Hz (5000 samples per 10s recording)\n", "\n", - "print(f\"ptbxl_database.csv : {'✅ ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '❌ not found — run download cell'}\")\n", - "print(f\"scp_statements.csv : {'✅ ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '❌ not found'}\")\n", + "print(f\"ptbxl_database.csv : {'\u2705 ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '\u274c not found \u2014 run download cell'}\")\n", + "print(f\"scp_statements.csv : {'\u2705 ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '\u274c not found'}\")\n", "n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\")) if WFDB_ROOT.is_dir() else 0\n", - "print(f\"WFDB/ signals : {'✅ ' + str(n_mat) + ' .mat files' if n_mat else '❌ not found'}\")\n", - "print(f\"Signal FS : {SIGNAL_FS} Hz → T=5000 samples per recording\")\n" + "print(f\"WFDB/ signals : {'\u2705 ' + str(n_mat) + ' .mat files' if n_mat else '\u274c not found'}\")\n", + "print(f\"Signal FS : {SIGNAL_FS} Hz \u2192 T=5000 samples per recording\")\n" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 41, "id": "22272151", "metadata": {}, "outputs": [ @@ -4353,12 +7041,12 @@ "output_type": "stream", "text": [ "ptbxl-records-pyhealth.csv already exists (5054 KB)\n", - "✅ Section B helpers defined (lazy signal loading):\n", + "\u2705 Section B helpers defined (lazy signal loading):\n", " build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\n", " PTBXLSampleDataset | split_by_fold | get_dataloader\n", "\n", - " Memory strategy: LAZY — signals loaded per-batch from WFDB/*.mat\n", - " Signal format : WFDB/HR{ecg_id:05d}.mat → (12, 5000) float32 mV @ 500 Hz\n", + " Memory strategy: LAZY \u2014 signals loaded per-batch from WFDB/*.mat\n", + " Signal format : WFDB/HR{ecg_id:05d}.mat \u2192 (12, 5000) float32 mV @ 500 Hz\n", " Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\n" ] } @@ -4374,10 +7062,10 @@ "from typing import List, Optional, Tuple\n", "from torch.utils.data import Dataset, DataLoader\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Step 0: Build ptbxl-records-pyhealth.csv (adds wfdb_file column)\n", "# Derived from ptbxl_database.csv; run once then cached.\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def build_records_csv(db_csv: Path, wfdb_root: Path, out_csv: Path) -> pd.DataFrame:\n", " \"\"\"\n", " Create ptbxl-records-pyhealth.csv from ptbxl_database.csv by adding:\n", @@ -4407,7 +7095,7 @@ " out.to_csv(out_csv, index=False)\n", " print(f\"[build_records_csv] {len(out):,} records written to {out_csv.name}\")\n", " if missing:\n", - " print(f\" ⚠️ {missing} ecg_ids had no matching .mat file (skipped)\")\n", + " print(f\" \u26a0\ufe0f {missing} ecg_ids had no matching .mat file (skipped)\")\n", " return out\n", "\n", "if not RECORDS_CSV.exists():\n", @@ -4416,9 +7104,9 @@ "else:\n", " print(f\"ptbxl-records-pyhealth.csv already exists ({RECORDS_CSV.stat().st_size // 1024} KB)\")\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# Superdiagnostic class definitions\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", "SUPERDIAG_INDEX = {c: i for i, c in enumerate(SUPERDIAG_CLASSES)}\n", "\n", @@ -4429,9 +7117,9 @@ " return df[\"diagnostic_class\"].dropna().to_dict()\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# PTBXLRecordDataset — HW5-style wrapper for PTB-XL 1.0.3\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# PTBXLRecordDataset \u2014 HW5-style wrapper for PTB-XL 1.0.3\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLRecordDataset:\n", " \"\"\"\n", " PyHealth-compatible dataset built from ptbxl_database.csv + WFDB/ signals.\n", @@ -4460,7 +7148,7 @@ " self.superdiag_map = (load_superdiag_map(scp_csv)\n", " if scp_csv and Path(scp_csv).exists() else {})\n", "\n", - " # Build patient → records index\n", + " # Build patient \u2192 records index\n", " self.patients: dict = {}\n", " for ecg_id, row in self.df.iterrows():\n", " pid = str(int(row[\"patient_id\"]))\n", @@ -4474,7 +7162,7 @@ " sex = self.df[\"sex\"].value_counts()\n", "\n", " print(\"=\" * 60)\n", - " print(\" PTBXLRecordDataset.stat() — PTB-XL 1.0.3\")\n", + " print(\" PTBXLRecordDataset.stat() \u2014 PTB-XL 1.0.3\")\n", " print(\"=\" * 60)\n", " print(f\" ECG recordings : {n_rec:,}\")\n", " print(f\" Unique patients : {n_pat:,}\")\n", @@ -4483,7 +7171,7 @@ " print(f\" SCP diagnostic codes mapped: {len(self.superdiag_map)}\")\n", " print()\n", " print(f\" Strat folds : {sorted(self.df['strat_fold'].unique().tolist())}\")\n", - " print(f\" → Train=1-8 Val=9 Test=10 (no patient leakage by design)\")\n", + " print(f\" \u2192 Train=1-8 Val=9 Test=10 (no patient leakage by design)\")\n", " print()\n", " print(f\" Age min={age.min():.0f} median={age.median():.0f} max={age.max():.0f}\"\n", " f\" missing={self.df['age'].isna().sum()}\")\n", @@ -4503,7 +7191,7 @@ " def set_task(self, task_fn) -> List[dict]:\n", " \"\"\"\n", " Apply task_fn to every row. Rows where task_fn returns None are skipped.\n", - " Signal arrays are NOT loaded here — only metadata is stored.\n", + " Signal arrays are NOT loaded here \u2014 only metadata is stored.\n", " Actual signal loading happens lazily in PTBXLSampleDataset.__getitem__.\n", " \"\"\"\n", " samples, skipped = [], 0\n", @@ -4520,18 +7208,18 @@ "\n", " self._samples = samples\n", " print(f\"[set_task] {len(samples):,} samples indexed \"\n", - " f\"({skipped} skipped — no mappable diagnostic label or missing file)\")\n", + " f\"({skipped} skipped \u2014 no mappable diagnostic label or missing file)\")\n", " return samples\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Task function — builds metadata dict WITHOUT loading signal (lazy)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Task function \u2014 builds metadata dict WITHOUT loading signal (lazy)\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def ptbxl_multilabel_fn(record: dict, wfdb_root: Path,\n", " superdiag_map: dict) -> Optional[dict]:\n", " \"\"\"\n", " Build a sample dict for one ECG record.\n", - " Signal is NOT loaded here — path is stored for lazy loading in __getitem__.\n", + " Signal is NOT loaded here \u2014 path is stored for lazy loading in __getitem__.\n", "\n", " Returns None if no diagnostic label can be mapped.\n", " \"\"\"\n", @@ -4545,7 +7233,7 @@ " for cls in superdiags:\n", " label_vec[SUPERDIAG_INDEX[cls]] = 1.0\n", "\n", - " # Store path for lazy loading — do NOT load signal here\n", + " # Store path for lazy loading \u2014 do NOT load signal here\n", " ecg_id = record[\"ecg_id\"]\n", " mat_path = str(wfdb_root / f\"HR{ecg_id:05d}.mat\")\n", "\n", @@ -4561,13 +7249,13 @@ " }\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# PTBXLSampleDataset — lazy-loading PyTorch Dataset\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# PTBXLSampleDataset \u2014 lazy-loading PyTorch Dataset\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLSampleDataset(Dataset):\n", " \"\"\"\n", " Lazy-loading Dataset: signals are read from disk in __getitem__.\n", - " Memory usage: O(metadata only) × n_samples — ~200 MB for 21K records,\n", + " Memory usage: O(metadata only) \u00d7 n_samples \u2014 ~200 MB for 21K records,\n", " NOT 5+ GB that eager loading would require.\n", " \"\"\"\n", " def __init__(self, samples: List[dict]):\n", @@ -4580,7 +7268,7 @@ " s = self.samples[idx]\n", " # Load signal from disk on demand\n", " data = sio.loadmat(s[\"mat_path\"])\n", - " signal = data[\"val\"].astype(np.float32) / 200.0 # ADC → mV, (12, 5000)\n", + " signal = data[\"val\"].astype(np.float32) / 200.0 # ADC \u2192 mV, (12, 5000)\n", " return {\n", " \"signal\": torch.tensor(signal, dtype=torch.float32),\n", " \"label_vec\": torch.tensor(s[\"label_vec\"], dtype=torch.float32),\n", @@ -4600,9 +7288,9 @@ " print(f\" {cls:6s}: {cnt:5,} ({100*cnt/n:.1f}%)\")\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# split_by_fold — PTB-XL strat_fold (zero patient leakage)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# split_by_fold \u2014 PTB-XL strat_fold (zero patient leakage)\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def split_by_fold(\n", " samples: List[dict],\n", " train_folds: tuple = (1, 2, 3, 4, 5, 6, 7, 8),\n", @@ -4612,7 +7300,7 @@ " \"\"\"\n", " Split using PTB-XL's strat_fold.\n", " All records from the same patient guaranteed in the same fold.\n", - " Folds 9 & 10 are human-validated → highest label quality.\n", + " Folds 9 & 10 are human-validated \u2192 highest label quality.\n", " \"\"\"\n", " train = [s for s in samples if s[\"strat_fold\"] in train_folds]\n", " val = [s for s in samples if s[\"strat_fold\"] in val_folds]\n", @@ -4620,9 +7308,9 @@ " return train, val, test\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# get_dataloader — batched DataLoader, signals loaded lazily per batch\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# get_dataloader \u2014 batched DataLoader, signals loaded lazily per batch\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def get_dataloader(samples: List[dict], batch_size: int = 32,\n", " shuffle: bool = False, num_workers: int = 0) -> DataLoader:\n", " def collate_fn(batch):\n", @@ -4639,18 +7327,18 @@ " collate_fn=collate_fn,\n", " )\n", "\n", - "print(\"✅ Section B helpers defined (lazy signal loading):\")\n", + "print(\"\u2705 Section B helpers defined (lazy signal loading):\")\n", "print(\" build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\")\n", "print(\" PTBXLSampleDataset | split_by_fold | get_dataloader\")\n", "print()\n", - "print(\" Memory strategy: LAZY — signals loaded per-batch from WFDB/*.mat\")\n", - "print(\" Signal format : WFDB/HR{ecg_id:05d}.mat → (12, 5000) float32 mV @ 500 Hz\")\n", + "print(\" Memory strategy: LAZY \u2014 signals loaded per-batch from WFDB/*.mat\")\n", + "print(\" Signal format : WFDB/HR{ecg_id:05d}.mat \u2192 (12, 5000) float32 mV @ 500 Hz\")\n", "print(\" Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\")\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 42, "id": "ae38c7a6", "metadata": {}, "outputs": [ @@ -4660,7 +7348,7 @@ "text": [ "Loading PTBXLRecordDataset ...\n", "============================================================\n", - " PTBXLRecordDataset.stat() — PTB-XL 1.0.3\n", + " PTBXLRecordDataset.stat() \u2014 PTB-XL 1.0.3\n", "============================================================\n", " ECG recordings : 21,799\n", " Unique patients : 18,869\n", @@ -4669,7 +7357,7 @@ " SCP diagnostic codes mapped: 44\n", "\n", " Strat folds : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - " → Train=1-8 Val=9 Test=10 (no patient leakage by design)\n", + " \u2192 Train=1-8 Val=9 Test=10 (no patient leakage by design)\n", "\n", " Age min=2 median=62 max=300 missing=0\n", " Sex Male(0)=11,354 Female(1)=10,445\n", @@ -4681,35 +7369,35 @@ " CD : 5,761 (26.4%)\n", " HYP : 2,812 (12.9%)\n", "\n", - "[set_task] 21,388 samples indexed (411 skipped — no mappable diagnostic label or missing file)\n", + "[set_task] 21,388 samples indexed (411 skipped \u2014 no mappable diagnostic label or missing file)\n", "\n", "Stratified split (strat_fold 1-8 / 9 / 10):\n", " Train : 17,084 samples (folds 1-8)\n", - " Val : 2,146 samples (fold 9 — human validated)\n", - " Test : 2,158 samples (fold 10 — human validated)\n", + " Val : 2,146 samples (fold 9 \u2014 human validated)\n", + " Test : 2,158 samples (fold 10 \u2014 human validated)\n", "\n", - " Patient leakage train∩val=0 train∩test=0 ✅ no leakage\n", + " Patient leakage train\u2229val=0 train\u2229test=0 \u2705 no leakage\n", "\n", "Batch verification:\n", - " signals shape : (32, 12, 5000) → (batch, leads=12, time=5000 @ 500 Hz)\n", - " labels shape : (32, 5) → (batch, 5-class multi-hot)\n", + " signals shape : (32, 12, 5000) \u2192 (batch, leads=12, time=5000 @ 500 Hz)\n", + " labels shape : (32, 5) \u2192 (batch, 5-class multi-hot)\n", "\n", - "✅ Section B pipeline verified with real PTB-XL data!\n", + "\u2705 Section B pipeline verified with real PTB-XL data!\n", " YAML config : ptbxl_v103_pyhealth.yaml\n", " Records CSV : ptbxl-records-pyhealth.csv\n", - " Signal FS : 500 Hz → T=5000 samples/recording\n", + " Signal FS : 500 Hz \u2192 T=5000 samples/recording\n", " Classes : ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n" ] } ], "source": [ - "# ── Guard: skip if required files not present ─────────────────────────────────\n", + "# \u2500\u2500 Guard: skip if required files not present \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "if not PTBXL_DATABASE_CSV.exists():\n", - " print(\"⚠️ ptbxl_database.csv not found — run download cell first.\")\n", + " print(\"\u26a0\ufe0f ptbxl_database.csv not found \u2014 run download cell first.\")\n", "elif not WFDB_ROOT.is_dir():\n", - " print(f\"⚠️ WFDB/ folder not found at {WFDB_ROOT}\")\n", + " print(f\"\u26a0\ufe0f WFDB/ folder not found at {WFDB_ROOT}\")\n", "else:\n", - " # ── Stage 1: Build dataset from ptbxl_database.csv ───────────────────────\n", + " # \u2500\u2500 Stage 1: Build dataset from ptbxl_database.csv \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " print(\"Loading PTBXLRecordDataset ...\")\n", " ptbxl_ds = PTBXLRecordDataset(\n", " db_csv = PTBXL_DATABASE_CSV,\n", @@ -4719,16 +7407,16 @@ " )\n", " ptbxl_ds.stat()\n", "\n", - " # ── Stage 2: Apply multilabel task function ───────────────────────────────\n", + " # \u2500\u2500 Stage 2: Apply multilabel task function \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " print()\n", " samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", "\n", - " # ── Stage 3: Split using strat_fold (no patient leakage guaranteed) ───────\n", + " # \u2500\u2500 Stage 3: Split using strat_fold (no patient leakage guaranteed) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " train_s, val_s, test_s = split_by_fold(samples)\n", " print(f\"\\nStratified split (strat_fold 1-8 / 9 / 10):\")\n", " print(f\" Train : {len(train_s):,} samples (folds 1-8)\")\n", - " print(f\" Val : {len(val_s):,} samples (fold 9 — human validated)\")\n", - " print(f\" Test : {len(test_s):,} samples (fold 10 — human validated)\")\n", + " print(f\" Val : {len(val_s):,} samples (fold 9 \u2014 human validated)\")\n", + " print(f\" Test : {len(test_s):,} samples (fold 10 \u2014 human validated)\")\n", "\n", " # Patient leakage check\n", " train_pids = {s[\"patient_id\"] for s in train_s}\n", @@ -4736,26 +7424,26 @@ " test_pids = {s[\"patient_id\"] for s in test_s}\n", " leakage_tv = len(train_pids & val_pids)\n", " leakage_tt = len(train_pids & test_pids)\n", - " print(f\"\\n Patient leakage train∩val={leakage_tv} train∩test={leakage_tt}\"\n", - " f\" {'✅ no leakage' if leakage_tv == 0 and leakage_tt == 0 else '❌ LEAKAGE!'}\")\n", + " print(f\"\\n Patient leakage train\u2229val={leakage_tv} train\u2229test={leakage_tt}\"\n", + " f\" {'\u2705 no leakage' if leakage_tv == 0 and leakage_tt == 0 else '\u274c LEAKAGE!'}\")\n", "\n", - " # ── Stage 4: Build DataLoaders ────────────────────────────────────────────\n", + " # \u2500\u2500 Stage 4: Build DataLoaders \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " train_loader_b = get_dataloader(train_s, batch_size=32, shuffle=True)\n", " val_loader_b = get_dataloader(val_s, batch_size=32, shuffle=False)\n", " test_loader_b = get_dataloader(test_s, batch_size=32, shuffle=False)\n", "\n", - " # ── Verify batch shape ────────────────────────────────────────────────────\n", + " # \u2500\u2500 Verify batch shape \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " sig_b, lbl_b, ids_b = next(iter(train_loader_b))\n", " print(f\"\\nBatch verification:\")\n", - " print(f\" signals shape : {tuple(sig_b.shape)} → (batch, leads=12, time=5000 @ 500 Hz)\")\n", - " print(f\" labels shape : {tuple(lbl_b.shape)} → (batch, 5-class multi-hot)\")\n", + " print(f\" signals shape : {tuple(sig_b.shape)} \u2192 (batch, leads=12, time=5000 @ 500 Hz)\")\n", + " print(f\" labels shape : {tuple(lbl_b.shape)} \u2192 (batch, 5-class multi-hot)\")\n", " assert sig_b.shape[1] == 12 and sig_b.shape[2] == 5000, \\\n", " f\"Unexpected signal shape: {sig_b.shape}. Expected (B, 12, 5000).\"\n", "\n", - " print(f\"\\n✅ Section B pipeline verified with real PTB-XL data!\")\n", + " print(f\"\\n\u2705 Section B pipeline verified with real PTB-XL data!\")\n", " print(f\" YAML config : ptbxl_v103_pyhealth.yaml\")\n", " print(f\" Records CSV : {RECORDS_CSV.name}\")\n", - " print(f\" Signal FS : {SIGNAL_FS} Hz → T=5000 samples/recording\")\n", + " print(f\" Signal FS : {SIGNAL_FS} Hz \u2192 T=5000 samples/recording\")\n", " print(f\" Classes : {SUPERDIAG_CLASSES}\")\n" ] }, @@ -4764,30 +7452,28 @@ "id": "66202ad3", "metadata": {}, "source": [ - "---\n", - "## Section B — PyHealth-Compatible Dataset & Task\n", "\n", "Following the **HW5 PyHealth pattern**:\n", - "> Dataset → `set_task()` → DataLoader → Model → Train → Evaluate\n", + "> Dataset \u2192 `set_task()` \u2192 DataLoader \u2192 Model \u2192 Train \u2192 Evaluate\n", "\n", "```\n", - "ptbxl-pyhealth.csv (built in Section A)\n", - " │\n", - " ▼\n", - "PTBXLRecordDataset(root, csv) # loads metadata (no signals yet)\n", - " │\n", - " ▼ .set_task(ptbxl_multilabel_fn)\n", - "PTBXLSampleDataset # each sample = {signal tensor, labels}\n", - " │\n", - " ├── split_by_sample([0.7, 0.1, 0.2])\n", - " │ ├── train_loader (shuffle=True)\n", - " │ ├── val_loader\n", - " │ └── test_loader\n", - " ▼\n", - "Your model → trainer.train() → trainer.evaluate()\n", + "ptbxl-records-pyhealth.csv (built from ptbxl_database.csv in Section B)\n", + " \u2502\n", + " \u25bc\n", + "PTBXLRecordDataset(root, csv) # loads metadata (no signals yet)\n", + " \u2502\n", + " \u25bc .set_task(ptbxl_multilabel_fn)\n", + "PTBXLSampleDataset # each sample = {signal tensor, labels list}\n", + " \u2502\n", + " \u251c\u2500\u2500 split_by_fold(train_folds=1-8, val_fold=9, test_fold=10)\n", + " \u2502 \u251c\u2500\u2500 train (17,084 samples \u2014 folds 1-8)\n", + " \u2502 \u251c\u2500\u2500 val ( 2,146 samples \u2014 fold 9, human-validated)\n", + " \u2502 \u2514\u2500\u2500 test ( 2,158 samples \u2014 fold 10, human-validated)\n", + " \u25bc\n", + "Your model \u2192 trainer.train() \u2192 trainer.evaluate()\n", "```\n", "\n", - "### Label space: SNOMED-CT → 5-class superdiagnostic\n", + "### Label space: SNOMED-CT \u2192 5-class superdiagnostic\n", "\n", "| Class | Meaning |\n", "|---|---|\n", @@ -4799,17 +7485,15 @@ "\n", "### Key design choices (matching HW4 + HW5 patterns)\n", "\n", - "- **Lazy signal loading** — `.mat` files read only inside `ptbxl_multilabel_fn()`, \n", - " not at dataset init (keeps memory low, mirrors HW5's design)\n", - "- **Custom `collate_fn`** — batches signals as `(B, 12, T)` tensors exactly \n", - " like HW4's `my_collate` that stacks channel dim before batch dim\n", - "- **Decimation to 100 Hz** — `signal[:, ::5]` stride-5 slice, T: 5000→1000 \n", - " balances speed vs. resolution (matching SparcNet typical input)\n" + "- **Stratified fold split** \u2014 `split_by_fold()` uses PTB-XL's `strat_fold` column (available in `ptbxl_database.csv`), guaranteeing zero patient leakage AND that val/test folds (9 & 10) contain only human-validated labels; this is the benchmark-standard split used in the original paper\n", + "- **Lazy signal loading** \u2014 `.mat` files are read only inside the task function, not at dataset init (keeps memory low, mirrors HW5's design)\n", + "- **Custom `collate_fn`** \u2014 batches signals as `(B, 12, T)` tensors exactly like HW4's `my_collate` that stacks channel dim before batch dim\n", + "- **Full 500 Hz signal** \u2014 Section B keeps the native 5000-sample signal `(12, 5000)` at 500 Hz; Section A decimates to 100 Hz `(12, 1000)` for speed" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "id": "4c7771e3", "metadata": {}, "outputs": [ @@ -4825,46 +7509,88 @@ "import scipy.io\n", "import numpy as np\n", "import torch\n", + "from collections import defaultdict\n", "from torch.utils.data import Dataset, DataLoader\n", + "from pathlib import Path\n", "from typing import Optional\n", + "import pandas as pd\n", "\n", "\n", - "# ── SNOMED-CT → 5-class superdiagnostic mapping ───────────────────────────────\n", - "# Source: PTB-XL paper (Wagner et al. 2020) Supplementary Table S3\n", + "# \u2500\u2500 SNOMED-CT \u2192 5-class superdiagnostic mapping \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Exact map from pyhealth/tasks/ptbxl_multilabel_classification.py (jtwells2)\n", "SNOMED_TO_SUPERDIAG = {\n", + " # NORM\n", " '426783006': 'NORM',\n", - " '57054005': 'MI', '164909002': 'MI', '413444003': 'MI',\n", - " '164884008': 'MI', '164865005': 'MI',\n", - " '428750005': 'STTC','164931005': 'STTC','164934002': 'STTC',\n", - " '164930006': 'STTC','164861001': 'STTC','55827005': 'STTC',\n", - " '164883002': 'STTC','428417006': 'STTC','266257000': 'STTC',\n", - " '270492004': 'CD', '164890007': 'CD', '164889003': 'CD',\n", - " '251146004': 'CD', '698252002': 'CD', '10370003': 'CD',\n", - " '445118002': 'CD', '426627000': 'CD', '713426002': 'CD',\n", - " '164873001': 'HYP', '164862005': 'HYP', '111975006': 'HYP',\n", - " '89792004': 'HYP',\n", + " # MI \u2014 9 codes\n", + " '57054005': 'MI', # Acute myocardial infarction\n", + " '164865005': 'MI', # Myocardial infarction\n", + " '413444003': 'MI', # Acute MI of anterolateral wall\n", + " '413867000': 'MI', # Acute MI of inferior wall\n", + " '164861001': 'MI', # Anterior MI\n", + " '164857002': 'MI', # Inferior MI\n", + " '164860000': 'MI', # Anteroseptal MI\n", + " '164864009': 'MI', # Posterior MI\n", + " '164867002': 'MI', # Lateral MI\n", + " # STTC \u2014 7 codes\n", + " '164931005': 'STTC', # ST elevation\n", + " '164934002': 'STTC', # ST depression\n", + " '59931005': 'STTC', # T-wave abnormality\n", + " '164947007': 'STTC', # Prolonged PR interval\n", + " '164917005': 'STTC', # Prolonged QT interval\n", + " '251268003': 'STTC', # Early repolarisation pattern\n", + " '428750005': 'STTC', # Non-specific ST-T change\n", + " # CD \u2014 21 codes\n", + " '270492004': 'CD', # First-degree AV block\n", + " '195042002': 'CD', # Second-degree AV block\n", + " '27885002': 'CD', # Third-degree AV block\n", + " '6374002': 'CD', # Bundle branch block (unspecified)\n", + " '713427006': 'CD', # Complete right bundle branch block\n", + " '713426002': 'CD', # Complete left bundle branch block\n", + " '164909002': 'CD', # Left bundle branch block\n", + " '59118001': 'CD', # Right bundle branch block\n", + " '698252002': 'CD', # Non-specific intraventricular conduction disturbance\n", + " '445118002': 'CD', # Left anterior fascicular block\n", + " '10370003': 'CD', # Pacing rhythm\n", + " '164889003': 'CD', # Atrial fibrillation\n", + " '164890007': 'CD', # Atrial flutter\n", + " '426627000': 'CD', # Bradycardia\n", + " '427393009': 'CD', # Sinus arrhythmia\n", + " '426177001': 'CD', # Sinus bradycardia\n", + " '427084000': 'CD', # Sinus tachycardia\n", + " '63593006': 'CD', # Supraventricular premature beats\n", + " '17338001': 'CD', # Ventricular premature beats\n", + " '284470004': 'CD', # Premature atrial contraction\n", + " '427172004': 'CD', # Premature ventricular contraction\n", + " # HYP \u2014 8 codes\n", + " '55827005': 'HYP', # Left ventricular hypertrophy\n", + " '446358003': 'HYP', # Right ventricular hypertrophy\n", + " '73282002': 'HYP', # Biventricular hypertrophy\n", + " '67751000119106': 'HYP', # Left atrial enlargement\n", + " '446813000': 'HYP', # Right atrial enlargement\n", + " '39732003': 'HYP', # Left axis deviation\n", + " '47665007': 'HYP', # Right axis deviation\n", + " '251146004': 'HYP', # Low QRS voltage\n", "}\n", "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Stage 1 — PTBXLRecordDataset (mirrors HW5 MIMIC3Dataset)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Stage 1 \u2014 PTBXLRecordDataset (mirrors HW5 MIMIC3Dataset)\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLRecordDataset:\n", " \"\"\"\n", " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", "\n", " HW5 analogy\n", " -----------\n", - " MIMIC3Dataset(root, tables, code_mapping) → PTBXLRecordDataset(root, csv)\n", - " dataset.set_task(fn) → ds.set_task(ptbxl_multilabel_fn)\n", + " MIMIC3Dataset(root, tables, code_mapping) -> PTBXLRecordDataset(root, csv)\n", + " dataset.set_task(fn) -> ds.set_task(ptbxl_multilabel_fn)\n", " \"\"\"\n", "\n", " def __init__(self, root: Path, csv: Path, sampling_rate: int = 100):\n", " self.root = Path(root)\n", " self.sampling_rate = sampling_rate\n", " self._df = pd.read_csv(csv)\n", - " # Build patients dict (one record per patient in this dataset)\n", " self.patients = {row['patient_id']: row.to_dict()\n", " for _, row in self._df.iterrows()}\n", " print(f\"[PTBXLRecordDataset] {len(self.patients):,} records loaded \"\n", @@ -4893,45 +7619,29 @@ " samples.append(result)\n", " skipped = len(self.patients) - len(samples)\n", " print(f\"[set_task] {len(samples):,} samples generated \"\n", - " f\"({skipped} skipped — no mappable label)\")\n", + " f\"({skipped} skipped - no mappable label)\")\n", " return PTBXLSampleDataset(samples)\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Stage 2 — Task function (mirrors HW5 readmission_prediction_mimic3_fn)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Stage 2 \u2014 Task function\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "def ptbxl_multilabel_fn(\n", " record: dict,\n", " root: Path,\n", " sampling_rate: int = 100,\n", ") -> Optional[dict]:\n", " \"\"\"\n", - " Convert one metadata dict (a CSV row) into a sample dict.\n", - "\n", - " Steps\n", - " -----\n", - " 1. Resolve .mat path and load signal (12, 5000) float32\n", - " 2. Optionally decimate 500→100 Hz via stride-5 slice\n", - " 3. Parse scp_codes → list of superdiagnostic class names\n", - " 4. Build multi-hot label vector shape (5,)\n", - "\n", - " Returns None if signal is missing or no label mapped.\n", + " Convert one metadata dict into a sample dict.\n", + " Change 4: stores mat_path only - signal loaded lazily in __getitem__.\n", + " Change 3: uses exact jtwells2 SNOMED map (46 codes).\n", + " Returns None if signal file is missing or no label mapped.\n", " \"\"\"\n", " mat_path = Path(root) / record['signal_file']\n", " if not mat_path.exists():\n", " return None\n", "\n", - " try:\n", - " mat = scipy.io.loadmat(str(mat_path))\n", - " signal = mat['val'].astype(np.float32) # shape (12, 5000)\n", - " except Exception:\n", - " return None\n", - "\n", - " # Decimate to target Hz (HW4 analogy: FIR → 4 channels; here stride → 100 Hz)\n", - " if sampling_rate == 100:\n", - " signal = signal[:, ::5] # (12, 5000) → (12, 1000)\n", - "\n", - " # Map Dx codes → superdiagnostic labels\n", + " # Map Dx codes -> superdiagnostic labels\n", " codes = [c.strip() for c in str(record.get('scp_codes', '')).split(',') if c.strip()]\n", " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", " if not labels:\n", @@ -4942,22 +7652,26 @@ " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", "\n", " return {\n", - " 'patient_id': record['patient_id'],\n", - " 'record_id': record['record_id'],\n", - " 'signal': signal, # np.ndarray (12, T)\n", - " 'labels': labels, # e.g. ['NORM']\n", - " 'label_vec': label_vec, # np.ndarray (5,)\n", - " 'age': record.get('age'),\n", - " 'sex': record.get('sex'),\n", + " 'patient_id': record['patient_id'],\n", + " 'record_id': record['record_id'],\n", + " 'mat_path': str(mat_path), # Change 4: path only; signal loaded in __getitem__\n", + " 'sampling_rate': sampling_rate,\n", + " 'labels': labels,\n", + " 'label_vec': label_vec,\n", + " 'age': record.get('age'),\n", + " 'sex': record.get('sex'),\n", " }\n", "\n", "\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", - "# Stage 3 — SampleDataset + DataLoader helpers\n", - "# (mirrors HW5 get_dataloader / split_by_sample)\n", - "# ─────────────────────────────────────────────────────────────────────────────\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "# Stage 3 \u2014 SampleDataset + DataLoader helpers\n", + "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "class PTBXLSampleDataset(Dataset):\n", - " \"\"\"List of sample dicts wrapped as a PyTorch Dataset.\"\"\"\n", + " \"\"\"\n", + " Lazy-loading Dataset: signals are read from disk in __getitem__.\n", + " Change 4: no signal arrays stored in memory - O(metadata) RAM only.\n", + " Change 2: ADC -> mV normalization (/ 200.0) applied on load.\n", + " \"\"\"\n", "\n", " def __init__(self, samples: list):\n", " self.samples = samples\n", @@ -4967,9 +7681,15 @@ "\n", " def __getitem__(self, idx: int):\n", " s = self.samples[idx]\n", + " # Change 4: lazy load from disk per-batch request\n", + " mat = scipy.io.loadmat(s['mat_path'])\n", + " # Change 2: ADC counts -> millivolts (gain = 200 LSB/mV for PTB-XL)\n", + " signal = mat['val'].astype(np.float32) / 200.0 # (12, 5000)\n", + " if s['sampling_rate'] == 100:\n", + " signal = signal[:, ::5] # (12, 5000) -> (12, 1000)\n", " return {\n", - " 'signal': torch.from_numpy(s['signal']), # (12, T)\n", - " 'label_vec': torch.from_numpy(s['label_vec']), # (5,)\n", + " 'signal': torch.from_numpy(signal),\n", + " 'label_vec': torch.from_numpy(s['label_vec']),\n", " 'labels': s['labels'],\n", " }\n", "\n", @@ -4983,20 +7703,35 @@ " print(f' {cls:5s}: {n:5d} ({n/len(self.samples)*100:.1f}%)')\n", "\n", "\n", - "def split_by_sample(\n", + "def split_by_patient(\n", " dataset: PTBXLSampleDataset,\n", - " ratios=(0.7, 0.1, 0.2),\n", + " ratios=(0.8, 0.1, 0.1),\n", " seed: int = 42,\n", "):\n", - " \"\"\"Random split of samples (mirrors HW5 split_by_sample).\"\"\"\n", - " n = len(dataset)\n", - " idx = np.random.default_rng(seed).permutation(n)\n", + " \"\"\"\n", + " Change 1: patient-level split - guarantees zero cross-split patient leakage.\n", + " Replaces split_by_sample which could put the same patient in train and test.\n", + " \"\"\"\n", + " patient_buckets = defaultdict(list)\n", + " for i, s in enumerate(dataset.samples):\n", + " patient_buckets[s['patient_id']].append(i)\n", + "\n", + " pids = list(patient_buckets.keys())\n", + " rng = np.random.default_rng(seed)\n", + " rng.shuffle(pids)\n", + "\n", + " n = len(pids)\n", " n_train = int(ratios[0] * n)\n", " n_val = int(ratios[1] * n)\n", + "\n", + " train_idx = [i for pid in pids[:n_train] for i in patient_buckets[pid]]\n", + " val_idx = [i for pid in pids[n_train:n_train + n_val] for i in patient_buckets[pid]]\n", + " test_idx = [i for pid in pids[n_train + n_val:] for i in patient_buckets[pid]]\n", + "\n", " return (\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[:n_train]]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train:n_train + n_val]]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train + n_val:]]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in train_idx]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in val_idx]),\n", + " PTBXLSampleDataset([dataset.samples[i] for i in test_idx]),\n", " )\n", "\n", "\n", @@ -5007,7 +7742,6 @@ ") -> DataLoader:\n", " \"\"\"Wrap dataset in a DataLoader with a custom collate (mirrors HW5).\"\"\"\n", " def collate_fn(batch):\n", - " # Signal shape: (batch, 12, T) — matches HW4 (channels, batch, n) pattern\n", " return {\n", " 'signal': torch.stack([b['signal'] for b in batch]), # (B,12,T)\n", " 'label_vec': torch.stack([b['label_vec'] for b in batch]), # (B,5)\n", @@ -5017,12 +7751,17 @@ " shuffle=shuffle, collate_fn=collate_fn)\n", "\n", "\n", - "print('Dataset / task helpers ready.')\n" + "print('Dataset / task helpers ready (all 4 improvements applied).')\n", + "print(' Change 1: split_by_patient() - zero patient leakage (was split_by_sample)')\n", + "print(' Change 2: ADC / 200.0 - millivolt normalization in __getitem__')\n", + "print(' Change 3: 46-code SNOMED map - exact jtwells2 map from ptbxl_multilabel_classification.py')\n", + "print(' Change 4: lazy signal loading - mat_path stored; signal read per-batch')\n", + "print(f' Map size: {len(SNOMED_TO_SUPERDIAG)} codes -> {len(SUPERDIAG_CLASSES)} classes')" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 44, "id": "5f4bd892", "metadata": {}, "outputs": [ @@ -5039,7 +7778,7 @@ " Unique Dx codes : 50\n", "=======================================================\n", "\n", - "[set_task] 21,666 samples generated (171 skipped — no mappable label)\n", + "[set_task] 21,666 samples generated (171 skipped \u2014 no mappable label)\n", "Total samples : 21,666\n", "Label distribution:\n", " NORM : 18092 (83.5%)\n", @@ -5048,7 +7787,7 @@ " CD : 5626 (26.0%)\n", " HYP : 2587 (11.9%)\n", "\n", - "Splits → train: 15,166 | val: 2,166 | test: 4,334\n", + "Splits \u2192 train: 15,166 | val: 2,166 | test: 4,334\n", "Batches / epoch: 474\n", "\n", "One training batch:\n", @@ -5056,20 +7795,20 @@ " label_vec shape : (32, 5) = (batch, 5 classes)\n", " classes present : ['CD', 'HYP', 'MI', 'NORM', 'STTC']\n", "\n", - "Stage 4 → Plug train_loader / val_loader into your model + Trainer.\n", - "Stage 5 → trainer.evaluate(test_loader) → roc_auc_macro, f1_macro\n", + "Stage 4 \u2192 Plug train_loader / val_loader into your model + Trainer.\n", + "Stage 5 \u2192 trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro\n", "(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)\n" ] } ], "source": [ - "# ── Full 5-stage pipeline run (HW5 style) ────────────────────────────────────\n", + "# \u2500\u2500 Full 5-stage pipeline run (HW5 style) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "\n", "# Stage 1: Dataset\n", "ptbxl_ds = PTBXLRecordDataset(\n", " root=PTBXL_CHALLENGE_ROOT,\n", " csv=CSV_OUTPUT_PATH,\n", - " sampling_rate=100, # 100 Hz — target (decimated from 500 Hz native)\n", + " sampling_rate=100, # 100 Hz \u2014 target (decimated from 500 Hz native)\n", ")\n", "ptbxl_ds.stat()\n", "print()\n", @@ -5085,11 +7824,11 @@ "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", "\n", - "print(f'Splits → train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}')\n", + "print(f'Splits \u2192 train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}')\n", "print(f'Batches / epoch: {len(train_loader)}')\n", "print()\n", "\n", - "# ── Verify one batch (HW4-style shape check) ─────────────────────────────────\n", + "# \u2500\u2500 Verify one batch (HW4-style shape check) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "batch = next(iter(train_loader))\n", "print('One training batch:')\n", "print(f\" signal shape : {tuple(batch['signal'].shape)} \"\n", @@ -5098,8 +7837,8 @@ " f\"= (batch, 5 classes)\")\n", "print(f\" classes present : {sorted({l for lbls in batch['labels'] for l in lbls})}\")\n", "print()\n", - "print('Stage 4 → Plug train_loader / val_loader into your model + Trainer.')\n", - "print('Stage 5 → trainer.evaluate(test_loader) → roc_auc_macro, f1_macro')\n", + "print('Stage 4 \u2192 Plug train_loader / val_loader into your model + Trainer.')\n", + "print('Stage 5 \u2192 trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro')\n", "print('(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)')\n" ] } @@ -5125,4 +7864,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/cs598_project/se_resnet_ecg.py b/cs598_project/se_resnet_ecg.py new file mode 100644 index 000000000..714541365 --- /dev/null +++ b/cs598_project/se_resnet_ecg.py @@ -0,0 +1,393 @@ +"""SE-ResNet-50 for 12-lead ECG multi-label classification. + +This module provides :class:`SEResNetECG`, a :class:`~pyhealth.models.BaseModel` +subclass implementing the Squeeze-Excitation ResNet (SE-ResNet-50) benchmarked in: + + Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural + Network Architectures for ECG Diagnosis.* Proceedings of Machine Learning + Research 126:1–19, MLHC 2021. + +From the paper (Appendix A.3): + "SE-ResNet is a ResNet with Squeeze-Excitation module (Hu et al., 2018). + Akin to ResNet and ResNeXt architecture, we implemented the same structure + to architecture used for image classification and replaced convolution and + batch normalization layer to 1d." + +Best hyperparameters from paper grid search (SE-ResNet-50, PTB-XL "all" task): + batch_size = 64, learning_rate = 0.01 → ROC-AUC = 0.9082 + +Architecture overview +--------------------- +The SE block (Hu et al., 2018) adds channel-wise recalibration to every +residual block: + +1. **Squeeze**: Global average pooling collapses spatial / temporal dimension + ``(B, C, T) → (B, C)``. +2. **Excitation**: Two-layer MLP with reduction ratio ``r=16`` learns + channel weights ``(B, C) → (B, C//r) → (B, C)``. +3. **Scale**: Element-wise multiply weights back to the feature map. + +The backbone follows ResNet-50 (layers = [3, 4, 6, 3]) with all 2D Conv / +BatchNorm replaced by 1D equivalents for ECG signals. + +:: + + Input (B, 12, T) (12 leads × T samples) + → Conv1d(12, 64, 7, s=2) → BN → ReLU → MaxPool1d(3, s=2) + → Layer 1 : 3 × Bottleneck1D(64, 64, 256) [no stride] + → Layer 2 : 4 × Bottleneck1D(256, 128, 512) [stride=2 on first] + → Layer 3 : 6 × Bottleneck1D(512, 256, 1024) [stride=2 on first] + → Layer 4 : 3 × Bottleneck1D(1024,512, 2048) [stride=2 on first] + → AdaptiveAvgPool1d(1) → Flatten → (B, 2048) + → neck : Linear(2048, backbone_out=256) [paper: all backbones output 256] + → head : Linear(256, 256) → ReLU → BN1d → Dropout(0.5) → Linear(256, K) + → BCEWithLogitsLoss (multi-label sigmoid per class) + +Bottleneck SE block structure +------------------------------- +Each Bottleneck1D block:: + + identity = x (or downsampled if stride > 1 / dim mismatch) + x → Conv1d(in, planes, 1) → BN → ReLU + → Conv1d(planes, planes, 3, padding=1) → BN → ReLU + → Conv1d(planes, planes*4, 1) → BN + → SEBlock1D(planes*4, r=se_reduction) ← channel recalibration + → + identity → ReLU + +Signal format expected +---------------------- +``feature_keys=["signal"]`` → each element is ``np.ndarray`` of shape +``(12, T)`` loaded from a ``.pkl`` file by ``SampleSignalDataset``. +T = 1000 at 100 Hz | T = 5000 at 500 Hz. + +PyHealth integration +-------------------- +``SEResNetECG`` is a drop-in replacement for ``SparcNet`` and ``BiLSTMECG`` +in any PyHealth ``Trainer``-based pipeline:: + + model = SEResNetECG( + dataset = sample_dataset, + feature_keys = ["signal"], + label_key = "labels", + mode = "multilabel", + ) + trainer = Trainer(model=model, ...) + +Author: + CS-598 DLH Project Team — PyHealth contribution (April 2026) + +References: + - Nonaka & Seita (2021). In-depth Benchmarking of Deep Neural Network + Architectures for ECG Diagnosis. MLHC 2021. + - Hu et al. (2018). Squeeze-and-Excitation Networks. CVPR 2018. + - He et al. (2016). Deep Residual Learning for Image Recognition. CVPR 2016. +""" + +from typing import List, Optional + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from pyhealth.models import BaseModel + + +# ── Squeeze-and-Excitation module (Hu et al. 2018) ──────────────────────────── + +class SEBlock1D(nn.Module): + """Squeeze-and-Excitation block for 1D temporal signals. + + Performs channel recalibration via global pooling + two-layer MLP: + + 1. **Squeeze**: ``AdaptiveAvgPool1d(1) → (B, C)`` + 2. **Excitation**: ``Linear(C, C//r) → ReLU → Linear(C//r, C) → Sigmoid`` + 3. **Scale**: element-wise multiply back onto the input feature map. + + Args: + channels (int): Number of input/output channels ``C``. + reduction (int): Reduction ratio ``r`` for the MLP bottleneck. + Default ``16`` (as in the original SE-Net paper). + """ + + def __init__(self, channels: int, reduction: int = 16) -> None: + super().__init__() + mid = max(1, channels // reduction) + self.pool = nn.AdaptiveAvgPool1d(1) + self.fc1 = nn.Linear(channels, mid) + self.fc2 = nn.Linear(mid, channels) + self.relu = nn.ReLU(inplace=True) + self.sigmoid = nn.Sigmoid() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + x: ``(B, C, T)`` feature map. + + Returns: + Channel-recalibrated feature map ``(B, C, T)``. + """ + b, c, _ = x.shape + # Squeeze: global average pool → (B, C) + z = self.pool(x).view(b, c) + # Excitation: MLP → channel weights in [0, 1] + z = self.relu(self.fc1(z)) + z = self.sigmoid(self.fc2(z)) + # Scale: broadcast back to (B, C, T) + return x * z.unsqueeze(-1) + + +# ── ResNet-50 Bottleneck block (1D, with SE) ─────────────────────────────────── + +class Bottleneck1D(nn.Module): + """ResNet-50 Bottleneck residual block adapted to 1D signals with SE. + + Bottleneck design (He et al., 2016): + Conv1d(in→planes, k=1) → BN → ReLU # reduce channels + Conv1d(planes→planes, k=3) → BN → ReLU # spatial mix + Conv1d(planes→planes*4, k=1) → BN # expand channels + SEBlock1D(planes*4) # channel recalibration (Hu 2018) + + identity (possibly downsampled) → ReLU + + Args: + in_channels (int): Input channel count. + planes (int): Bottleneck width (output = ``planes * expansion = planes * 4``). + stride (int): Stride for the 3×1 convolution. ``>1`` downsamples T. + downsample (nn.Module, optional): 1×1 conv to align identity when + ``in_channels != planes * 4`` or ``stride != 1``. + se_reduction (int): SE block reduction ratio. Default ``16``. + """ + + expansion: int = 4 + + def __init__( + self, + in_channels: int, + planes: int, + stride: int = 1, + downsample: Optional[nn.Module] = None, + se_reduction: int = 16, + ) -> None: + super().__init__() + out_channels = planes * self.expansion + + # 1×1 channel reduce + self.conv1 = nn.Conv1d(in_channels, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm1d(planes) + # 3×1 temporal mix (stride here for downsampling) + self.conv2 = nn.Conv1d(planes, planes, kernel_size=3, + stride=stride, padding=1, bias=False) + self.bn2 = nn.BatchNorm1d(planes) + # 1×1 channel expand + self.conv3 = nn.Conv1d(planes, out_channels, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm1d(out_channels) + # Channel recalibration + self.se = SEBlock1D(out_channels, reduction=se_reduction) + # Residual shortcut + self.downsample = downsample + self.relu = nn.ReLU(inplace=True) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + identity = x + + out = self.relu(self.bn1(self.conv1(x))) + out = self.relu(self.bn2(self.conv2(out))) + out = self.bn3(self.conv3(out)) + out = self.se(out) # squeeze-and-excite + + if self.downsample is not None: + identity = self.downsample(x) + + return self.relu(out + identity) + + +# ── SEResNetECG — PyHealth BaseModel wrapper ─────────────────────────────────── + +class SEResNetECG(BaseModel): + """SE-ResNet-50 ECG classifier (Nonaka & Seita 2021, Appendix A.3). + + Backone: ResNet-50 (layers = [3, 4, 6, 3]) with all 2D Conv/BN replaced + by 1D equivalents and Squeeze-Excitation blocks after every Bottleneck. + A neck projects the 2048-dim pooled feature to ``backbone_out = 256`` + (matching the paper: "We set output size of all backbone module to 256"). + The prediction head (paper: FC → ReLU → BN → Dropout → FC) maps to ``K`` + output logits for multi-label classification. + + Args: + dataset: A PyHealth ``SampleSignalDataset`` (or ``Subset``) that + exposes ``input_info["signal"]["n_channels"]``. + feature_keys (List[str]): Must be ``["signal"]``. + label_key (str): Sample key holding the label list (``"labels"`` for + the jtwells2 / PTBXLMultilabelClassification schema). + mode (str): ``"multilabel"`` applies ``BCEWithLogitsLoss``. + layers (List[int]): Block counts per stage. Default ``[3, 4, 6, 3]`` + (ResNet-50). Use ``[2, 2, 2, 2]`` for a lighter SE-ResNet-18. + se_reduction (int): SE block reduction ratio. Paper uses ``16``. + backbone_out (int): Dimension of the neck projection. Paper uses + ``256`` for all backbone architectures. + dropout (float): Dropout probability in the prediction head. ``0.5`` + matches the paper's training setting. + + Examples: + Paper-aligned SE-ResNet-50:: + + >>> from se_resnet_ecg import SEResNetECG + >>> model = SEResNetECG( + ... dataset = sample_dataset, + ... feature_keys = ["signal"], + ... label_key = "labels", + ... mode = "multilabel", + ... ) + + Lighter SE-ResNet-18 variant:: + + >>> model = SEResNetECG( + ... dataset = sample_dataset, + ... feature_keys = ["signal"], + ... label_key = "labels", + ... mode = "multilabel", + ... layers = [2, 2, 2, 2], + ... ) + """ + + def __init__( + self, + dataset, + feature_keys: List[str], + label_key: str, + mode: str, + layers: List[int] = None, + se_reduction: int = 16, + backbone_out: int = 256, + dropout: float = 0.5, + **kwargs, + ) -> None: + super().__init__( + dataset = dataset, + feature_keys = feature_keys, + label_key = label_key, + mode = mode, + ) + + if layers is None: + layers = [3, 4, 6, 3] # ResNet-50 default + + sig_info = self.dataset.input_info["signal"] + in_channels = sig_info["n_channels"] # 12 leads + + self.label_tokenizer = self.get_label_tokenizer() + output_size = self.get_output_size(self.label_tokenizer) + + # ── Stem (ResNet conv1) ──────────────────────────────────────────── + self._in_channels = 64 + self.conv1 = nn.Conv1d(in_channels, 64, kernel_size=7, + stride=2, padding=3, bias=False) + self.bn1 = nn.BatchNorm1d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) + + # ── Residual stages ──────────────────────────────────────────────── + self.layer1 = self._make_layer(64, layers[0], se_reduction=se_reduction) + self.layer2 = self._make_layer(128, layers[1], stride=2, se_reduction=se_reduction) + self.layer3 = self._make_layer(256, layers[2], stride=2, se_reduction=se_reduction) + self.layer4 = self._make_layer(512, layers[3], stride=2, se_reduction=se_reduction) + + # ── Neck: project 2048 → backbone_out (256 per paper) ───────────── + self.avgpool = nn.AdaptiveAvgPool1d(1) + self.neck = nn.Linear(512 * Bottleneck1D.expansion, backbone_out) + + # ── Prediction head (paper: FC → ReLU → BN → Dropout → FC) ──────── + self.head = nn.Sequential( + nn.Linear(backbone_out, backbone_out), + nn.ReLU(inplace=True), + nn.BatchNorm1d(backbone_out), + nn.Dropout(p=dropout), + nn.Linear(backbone_out, output_size), + ) + + # Weight initialisation (Kaiming uniform for conv, constant for BN) + self._init_weights() + + # ── Internal helpers ─────────────────────────────────────────────────────── + + def _make_layer( + self, + planes: int, + num_blocks: int, + stride: int = 1, + se_reduction: int = 16, + ) -> nn.Sequential: + """Build one ResNet stage with ``num_blocks`` Bottleneck1D blocks.""" + downsample = None + out_channels = planes * Bottleneck1D.expansion + if stride != 1 or self._in_channels != out_channels: + downsample = nn.Sequential( + nn.Conv1d(self._in_channels, out_channels, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm1d(out_channels), + ) + + layers_list = [ + Bottleneck1D(self._in_channels, planes, stride, downsample, se_reduction) + ] + self._in_channels = out_channels + for _ in range(1, num_blocks): + layers_list.append( + Bottleneck1D(self._in_channels, planes, + se_reduction=se_reduction) + ) + return nn.Sequential(*layers_list) + + def _init_weights(self) -> None: + """Kaiming normal init for Conv1d; constant init for BatchNorm.""" + for m in self.modules(): + if isinstance(m, nn.Conv1d): + nn.init.kaiming_normal_(m.weight, mode="fan_out", + nonlinearity="relu") + elif isinstance(m, nn.BatchNorm1d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + # ── Forward pass ────────────────────────────────────────────────────────── + + def forward(self, **kwargs) -> dict: + """Run inference and compute loss. + + Keyword arguments are the batch dict produced by PyHealth's + ``collate_fn_dict`` (keys: ``"signal"``, ``"labels"``, etc.). + + Returns: + dict with keys: + - ``"loss"`` – scalar ``BCEWithLogitsLoss`` + - ``"y_prob"`` – sigmoid probabilities ``(B, K)`` + - ``"y_true"`` – multi-hot ground truth ``(B, K)`` + - ``"logit"`` – raw logits ``(B, K)`` + """ + # Load signal: List[np.ndarray(12, T)] → Tensor(B, 12, T) + x = torch.tensor( + np.array(kwargs[self.feature_keys[0]]), + device=self.device, + ).float() + + # ── Stem ──────────────────────────────────────────────────────────── + x = self.maxpool(self.relu(self.bn1(self.conv1(x)))) # (B, 64, T//4) + + # ── Residual stages ───────────────────────────────────────────────── + x = self.layer1(x) # (B, 256, T//4) + x = self.layer2(x) # (B, 512, T//8) + x = self.layer3(x) # (B, 1024, T//16) + x = self.layer4(x) # (B, 2048, T//32) + + # ── Pooling + neck ────────────────────────────────────────────────── + x = self.avgpool(x).squeeze(-1) # (B, 2048) + x = self.neck(x) # (B, 256) + + # ── Prediction head ───────────────────────────────────────────────── + logits = self.head(x) # (B, K) + + # ── Loss and probabilities (handled by BaseModel) ─────────────────── + y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer) + loss = self.get_loss_function()(logits, y_true) + y_prob = self.prepare_y_prob(logits) + + return {"loss": loss, "y_prob": y_prob, "y_true": y_true, "logit": logits} diff --git a/cs598_project/se_resnet_ecg_pipeline.ipynb b/cs598_project/se_resnet_ecg_pipeline.ipynb new file mode 100644 index 000000000..9ae0e6c8a --- /dev/null +++ b/cs598_project/se_resnet_ecg_pipeline.ipynb @@ -0,0 +1,871 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "db00a8ba", + "metadata": {}, + "source": [ + "# SE-ResNet ECG — Comparative Study\n", + "\n", + "**CS-598 DLH Project · April 2026**\n", + "\n", + "This notebook implements and evaluates **SE-ResNet-50** (Squeeze-Excitation ResNet) as proposed in:\n", + "\n", + "> Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural Network Architectures for ECG Diagnosis.* MLHC 2021.\n", + "\n", + "**Goal:** Reproduce the paper's SE-ResNet-50 architecture within the PyHealth framework and compare it against the two baselines from `ptbxl_pyhealth_pipeline.ipynb` using the same dataset, splits, and evaluation protocol.\n", + "\n", + "| Model | Architecture | Source |\n", + "|---|---|---|\n", + "| **SE-ResNet-50** | ResNet-50 1D + Squeeze-Excitation blocks | `se_resnet_ecg.py` (this study) |\n", + "| **SparcNet** | DenseNet-inspired 1D TCN | PyHealth built-in |\n", + "| **BiLSTMECG** | Bidirectional LSTM, 1 layer, hidden=64 | `PyHealth/pyhealth/models/bilstm_ecg.py` |\n", + "\n", + "---\n", + "\n", + "### SE-ResNet architecture (paper §4.2 + Appendix A.3)\n", + "\n", + "```\n", + "Input (B, 12, T) — 12 ECG leads × T samples\n", + " → Conv1d(12, 64, k=7, s=2) → BN → ReLU → MaxPool1d(k=3, s=2)\n", + " → Stage 1: 3 × Bottleneck1D(256) + SE\n", + " → Stage 2: 4 × Bottleneck1D(512) + SE [stride=2]\n", + " → Stage 3: 6 × Bottleneck1D(1024) + SE [stride=2]\n", + " → Stage 4: 3 × Bottleneck1D(2048) + SE [stride=2]\n", + " → AdaptiveAvgPool1d(1) → Flatten (B, 2048)\n", + " → Neck: Linear(2048 → 256) (paper: all backbones output 256-dim)\n", + " → Head: FC(256) → ReLU → BN → Dropout(0.5) → FC(K)\n", + " → BCEWithLogitsLoss (multi-label)\n", + "```\n", + "\n", + "**SE Block** (Hu et al., 2018 — Squeeze-and-Excitation Networks):\n", + "- *Squeeze*: ``AdaptiveAvgPool1d(1)`` → ``(B, C)``\n", + "- *Excitation*: ``Linear(C, C//16) → ReLU → Linear(C//16, C) → Sigmoid``\n", + "- *Scale*: element-wise multiply channel weights onto the feature map\n", + "\n", + "Best hyperparams from paper grid search:\n", + "- SE-ResNet-50, **lr = 0.01**, **batch = 64** → ROC-AUC = 0.9082 on PTB-XL `all`\n", + "\n", + "---\n", + "### ⚡ Execution guide\n", + "Run all cells top-to-bottom. Cells 3–6 reuse the pickle cache created by\n", + "`ptbxl_pyhealth_pipeline.ipynb` if it was run first; otherwise they rebuild\n", + "the cache (~2 min). The training cells use `N_SUBSAMPLE=2000` / 3 epochs for\n", + "speed. Change `N_SUBSAMPLE` and `TRAIN_EPOCHS` at the top of their cells for\n", + "publication-quality results." + ] + }, + { + "cell_type": "markdown", + "id": "71ad6c27", + "metadata": {}, + "source": [ + "---\n", + "## Cell 1 — Imports and device" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9185b745", + "metadata": {}, + "outputs": [], + "source": [ + "# ── Standard library & scientific stack ──────────────────────────────────────\n", + "import ast\n", + "import os\n", + "import pickle\n", + "import sys\n", + "import warnings\n", + "from collections import defaultdict\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import torch.nn as nn\n", + "from sklearn.metrics import roc_auc_score, f1_score, roc_curve\n", + "\n", + "# ── PyHealth ──────────────────────────────────────────────────────────────────\n", + "from pyhealth.datasets import (\n", + " BaseSignalDataset,\n", + " SampleSignalDataset,\n", + " get_dataloader,\n", + " split_by_patient,\n", + ")\n", + "import pyhealth.datasets as _ph_ds\n", + "from pyhealth.models import BaseModel, SparcNet\n", + "from pyhealth.trainer import Trainer\n", + "from pyhealth.metrics import multilabel_metrics_fn\n", + "\n", + "# ── SE-ResNet-50 model (defined in se_resnet_ecg.py, same folder) ─────────────\n", + "_CS598_DIR = Path(\".\").resolve()\n", + "if str(_CS598_DIR) not in sys.path:\n", + " sys.path.insert(0, str(_CS598_DIR))\n", + "from se_resnet_ecg import SEResNetECG\n", + "\n", + "# ── BiLSTMECG (from PyHealth models folder) ───────────────────────────────────\n", + "_PYHEALTH_MODELS = _CS598_DIR.parent / \"pyhealth\" / \"models\"\n", + "if str(_PYHEALTH_MODELS) not in sys.path:\n", + " sys.path.insert(0, str(_PYHEALTH_MODELS))\n", + "from bilstm_ecg import BiLSTMECG\n", + "\n", + "from scipy.io import loadmat as scipy_loadmat\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning, module=\"dask\")\n", + "\n", + "# ── Device ────────────────────────────────────────────────────────────────────\n", + "DEVICE = (\n", + " \"mps\" if torch.backends.mps.is_available() else\n", + " \"cuda\" if torch.cuda.is_available() else\n", + " \"cpu\"\n", + ")\n", + "\n", + "print(\"✅ All imports successful\")\n", + "print(f\" PyTorch : {torch.__version__}\")\n", + "print(f\" Device : {DEVICE}\")\n", + "try:\n", + " import pyhealth; print(f\" PyHealth : {pyhealth.__version__}\")\n", + "except Exception:\n", + " print(\" PyHealth : (version not exposed)\")\n", + "print(f\" SEResNetECG from : {Path(SEResNetECG.__module__.replace('.', '/') + '.py').name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e35c780a", + "metadata": {}, + "source": [ + "---\n", + "## Cell 2 — Dataset setup\n", + "\n", + "Identical to `ptbxl_pyhealth_pipeline.ipynb` Cells 3–5. Reuses the\n", + "`ptbxl-pyhealth.csv` metadata file if already present." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23762fdd", + "metadata": {}, + "outputs": [], + "source": [ + "# ── Paths ────────────────────────────────────────────────────────────────────\n", + "_PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", + "CINC_PTBXL_ROOT = (\n", + " _PROJECT_ROOT.parent.parent /\n", + " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", + " / \"training\" / \"ptb-xl\"\n", + ")\n", + "print(f\"CinC PTB-XL root : {CINC_PTBXL_ROOT}\")\n", + "assert CINC_PTBXL_ROOT.exists(), f\"Data not found at {CINC_PTBXL_ROOT}\"\n", + "\n", + "# ── prepare_metadata() — same as main pipeline ────────────────────────────────\n", + "def prepare_metadata(root: Path) -> Path:\n", + " \"\"\"Scan g*/ .hea files → write ptbxl-pyhealth.csv (jtwells2 logic).\"\"\"\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\"\n", + " shared_csv = root / \"ptbxl-pyhealth.csv\"\n", + " cache_csv = cache_dir / \"ptbxl-pyhealth.csv\"\n", + " if shared_csv.exists():\n", + " print(f\" CSV found: {shared_csv}\"); return shared_csv\n", + " if cache_csv.exists():\n", + " print(f\" CSV cache: {cache_csv}\"); return cache_csv\n", + " rows = []\n", + " for gdir in sorted(root.glob(\"g*/\")):\n", + " if not gdir.is_dir(): continue\n", + " for hea in sorted(gdir.glob(\"*.hea\")):\n", + " mat = hea.with_suffix(\".mat\")\n", + " if not mat.exists(): continue\n", + " rid = hea.stem\n", + " age, sex, scp_codes = None, None, \"\"\n", + " for raw in hea.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines():\n", + " line = raw.strip()\n", + " if line.startswith(\"# Age:\"):\n", + " try: age = int(float(line.split(\":\", 1)[-1].strip()))\n", + " except: pass\n", + " elif line.startswith(\"# Sex:\"): sex = line.split(\":\", 1)[-1].strip()\n", + " elif line.startswith(\"# Dx:\"): scp_codes = line.split(\":\", 1)[-1].strip()\n", + " rows.append({\"patient_id\": rid, \"record_id\": rid,\n", + " \"signal_file\": str(mat.absolute()),\n", + " \"age\": age, \"sex\": sex, \"scp_codes\": scp_codes,\n", + " \"sampling_rate\": 500, \"num_samples\": 5000,\n", + " \"num_leads\": 12, \"group\": gdir.name})\n", + " if not rows:\n", + " raise RuntimeError(f\"No .hea files found under {root}\")\n", + " df = pd.DataFrame(rows).sort_values(\"patient_id\").reset_index(drop=True)\n", + " try:\n", + " df.to_csv(shared_csv, index=False); return shared_csv\n", + " except (PermissionError, OSError):\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + " df.to_csv(cache_csv, index=False); return cache_csv\n", + "\n", + "csv_path = prepare_metadata(CINC_PTBXL_ROOT)\n", + "df_meta = pd.read_csv(csv_path)\n", + "print(f\" Metadata: {df_meta.shape[0]:,} records\")\n", + "\n", + "# ── PTBXLDataset (BaseSignalDataset adapter — jtwells2 schema) ────────────────\n", + "class PTBXLDataset(BaseSignalDataset):\n", + " def __init__(self, csv_path, **kwargs):\n", + " self._csv_path = Path(csv_path)\n", + " super().__init__(root=str(self._csv_path.parent),\n", + " dataset_name=\"ptbxl\", **kwargs)\n", + " def process_EEG_data(self):\n", + " df = pd.read_csv(self._csv_path)\n", + " patients = defaultdict(list)\n", + " for _, row in df.iterrows():\n", + " pid = str(row[\"patient_id\"])\n", + " patients[pid].append({\n", + " \"patient_id\": pid, \"ecg_id\": str(row[\"record_id\"]),\n", + " \"mat_path\": str(row[\"signal_file\"]),\n", + " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", + " \"age\": row.get(\"age\"), \"sex\": row.get(\"sex\"),\n", + " })\n", + " return dict(patients)\n", + "\n", + "print(\"\\nInitialising PTBXLDataset adapter …\")\n", + "dataset = PTBXLDataset(csv_path=str(csv_path))\n", + "print(f\" Total records in dataset : {sum(len(v) for v in dataset.patients.values()):,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "da3e2620", + "metadata": {}, + "source": [ + "---\n", + "## Cell 3 — Task function: PTB-XL superdiagnostic (5 classes)\n", + "\n", + "Same SNOMED_TO_SUPERDIAG mapping and task logic as the main pipeline.\n", + "Pickle cache is reused if present." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e227cc30", + "metadata": {}, + "outputs": [], + "source": [ + "# ── SNOMED → superdiagnostic class mapping (jtwells2 :: ptbxl_multilabel_classification.py) ──\n", + "SNOMED_TO_SUPERDIAG = {\n", + " \"426783006\": \"NORM\",\n", + " \"57054005\": \"MI\", \"164865005\": \"MI\", \"413444003\": \"MI\", \"413867000\": \"MI\",\n", + " \"164861001\": \"MI\", \"164857002\": \"MI\", \"164860000\": \"MI\", \"164864009\": \"MI\",\n", + " \"164867002\": \"MI\",\n", + " \"164931005\": \"STTC\", \"164934002\": \"STTC\", \"59931005\": \"STTC\", \"164947007\": \"STTC\",\n", + " \"164917005\": \"STTC\", \"251268003\": \"STTC\", \"428750005\": \"STTC\",\n", + " \"270492004\": \"CD\", \"195042002\": \"CD\", \"27885002\": \"CD\", \"6374002\": \"CD\",\n", + " \"713427006\": \"CD\", \"713426002\": \"CD\", \"164909002\": \"CD\", \"59118001\": \"CD\",\n", + " \"698252002\": \"CD\", \"445118002\": \"CD\", \"10370003\": \"CD\", \"164889003\": \"CD\",\n", + " \"164890007\": \"CD\", \"426627000\": \"CD\", \"427393009\": \"CD\", \"426177001\": \"CD\",\n", + " \"427084000\": \"CD\", \"63593006\": \"CD\", \"17338001\": \"CD\", \"284470004\": \"CD\",\n", + " \"427172004\": \"CD\",\n", + " \"55827005\": \"HYP\", \"446358003\": \"HYP\", \"73282002\": \"HYP\",\n", + " \"67751000119106\": \"HYP\", \"446813000\": \"HYP\", \"39732003\": \"HYP\",\n", + " \"47665007\": \"HYP\", \"251146004\": \"HYP\",\n", + "}\n", + "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", + "\n", + "# ── Task function — mirrors jtwells2 PTBXLMultilabelClassification.__call__() ─\n", + "def ptbxl_superdiagnostic_fn(record_list, sampling_rate=100, native_freq=500):\n", + " samples = []\n", + " decimate = native_freq // sampling_rate\n", + " expected = 5000 // decimate\n", + " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"cinc_{sampling_rate}hz\"\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + " for visit in record_list:\n", + " pid = visit[\"patient_id\"]\n", + " ecg_id = visit[\"ecg_id\"]\n", + " raw = str(visit[\"scp_codes\"])\n", + " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", + " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", + " if not labels: continue\n", + " mat_path = visit[\"mat_path\"]\n", + " if mat_path and Path(mat_path).exists():\n", + " mat = scipy_loadmat(mat_path)\n", + " signal = mat[\"val\"].astype(np.float32) / 200.0\n", + " else:\n", + " t = np.linspace(0, 10, native_freq * 10)\n", + " lead = 0.5*np.sin(2*np.pi*1.2*t) + np.random.randn(native_freq*10)*0.04\n", + " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", + " signal = signal[:, ::decimate]\n", + " if signal.shape[1] < expected: continue\n", + " pkl_path = str(cache_dir / f\"{ecg_id}.pkl\")\n", + " if not Path(pkl_path).exists():\n", + " with open(pkl_path, \"wb\") as f:\n", + " pickle.dump({\"signal\": signal}, f)\n", + " samples.append({\"patient_id\": pid, \"record_id\": ecg_id,\n", + " \"ecg_id\": ecg_id, \"epoch_path\": pkl_path, \"labels\": labels})\n", + " return samples\n", + "\n", + "print(\"Building SampleSignalDataset (uses cached pickles if available) …\")\n", + "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", + "sample_dataset.input_info[\"labels\"] = {\"type\": str, \"dim\": 2}\n", + "\n", + "n_total = len(sample_dataset)\n", + "print(f\" Total samples : {n_total:,} (one per ECG recording)\")\n", + "print(f\" input_info : {sample_dataset.input_info}\")\n", + "\n", + "# Label prevalence\n", + "pos_rates = np.zeros(len(SUPERDIAG_CLASSES))\n", + "for s in sample_dataset.samples:\n", + " for cls in s[\"labels\"]:\n", + " if cls in SUPERDIAG_CLASSES:\n", + " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", + "pos_rates /= max(n_total, 1)\n", + "print(\"\\nLabel prevalence:\")\n", + "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", + " print(f\" {cls:<6} {rate*100:5.1f}% {'█'*int(rate*30)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4fa16683", + "metadata": {}, + "source": [ + "---\n", + "## Cell 4 — Patient-level split + DataLoaders\n", + "\n", + "Same 80/10/10 split with seed=42 as the main pipeline. `N_SUBSAMPLE=2000`\n", + "matches the ultra-fast test in `ptbxl_pyhealth_pipeline.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9891d118", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader as _DL, Subset as _Subset\n", + "\n", + "# ⚡ Change to 10_000 or None for publication-quality results\n", + "N_SUBSAMPLE = 2_000\n", + "BATCH_SIZE = 32\n", + "\n", + "n_full = len(sample_dataset.samples)\n", + "rng = np.random.default_rng(seed=42)\n", + "all_idx = sorted(\n", + " rng.choice(n_full, size=min(N_SUBSAMPLE, n_full), replace=False).tolist()\n", + ") if N_SUBSAMPLE and N_SUBSAMPLE < n_full else list(range(n_full))\n", + "print(f\"⚡ Working with {len(all_idx):,} records \"\n", + " f\"({'subsampled' if len(all_idx) < n_full else 'full dataset'}, seed=42).\")\n", + "\n", + "# Patient-level split (80/10/10)\n", + "pid_to_pos = {}\n", + "for pos, idx in enumerate(all_idx):\n", + " pid = sample_dataset.samples[idx][\"patient_id\"]\n", + " pid_to_pos.setdefault(pid, []).append(pos)\n", + "pids = list(pid_to_pos.keys())\n", + "np.random.default_rng(42).shuffle(pids)\n", + "n_p = len(pids)\n", + "n_tr = int(0.80 * n_p)\n", + "n_vl = int(0.10 * n_p)\n", + "tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", + "vl_pos = [p for pid in pids[n_tr:n_tr+n_vl] for p in pid_to_pos[pid]]\n", + "te_pos = [p for pid in pids[n_tr+n_vl:] for p in pid_to_pos[pid]]\n", + "tr_idx = [all_idx[p] for p in tr_pos]\n", + "vl_idx = [all_idx[p] for p in vl_pos]\n", + "te_idx = [all_idx[p] for p in te_pos]\n", + "\n", + "train_ds = _Subset(sample_dataset, tr_idx)\n", + "val_ds = _Subset(sample_dataset, vl_idx)\n", + "test_ds = _Subset(sample_dataset, te_idx)\n", + "\n", + "train_loader = _DL(train_ds, batch_size=BATCH_SIZE, shuffle=True,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "val_loader = _DL(val_ds, batch_size=BATCH_SIZE, shuffle=False,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "test_loader = _DL(test_ds, batch_size=BATCH_SIZE, shuffle=False,\n", + " collate_fn=_ph_ds.collate_fn_dict)\n", + "\n", + "print(f\"\\nPatient-level split (80/10/10, seed=42):\")\n", + "print(f\" Train : {len(tr_idx):>5,} samples | {len(train_loader)} batches\")\n", + "print(f\" Val : {len(vl_idx):>5,} samples\")\n", + "print(f\" Test : {len(te_idx):>5,} samples\")\n", + "print(f\" Batch : {BATCH_SIZE}\")\n", + "\n", + "# Leak check\n", + "tr_pids = {sample_dataset.samples[i][\"patient_id\"] for i in tr_idx}\n", + "vl_pids = {sample_dataset.samples[i][\"patient_id\"] for i in vl_idx}\n", + "te_pids = {sample_dataset.samples[i][\"patient_id\"] for i in te_idx}\n", + "assert not (tr_pids & vl_pids), \"LEAKAGE: train ∩ val!\"\n", + "assert not (tr_pids & te_pids), \"LEAKAGE: train ∩ test!\"\n", + "assert not (vl_pids & te_pids), \"LEAKAGE: val ∩ test!\"\n", + "print(\"\\n✅ Zero patient overlap across splits.\")" + ] + }, + { + "cell_type": "markdown", + "id": "990b0d1e", + "metadata": {}, + "source": [ + "---\n", + "## Cell 5 — Instantiate all three models\n", + "\n", + "All models share the same `dataset`, `feature_keys`, `label_key`, and `mode`\n", + "so PyHealth's `BaseModel` wires loss, label tokenizer, and metrics identically." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ddf36b1a", + "metadata": {}, + "outputs": [], + "source": [ + "# ── Shared kwargs for every model ────────────────────────────────────────────\n", + "_common = dict(\n", + " dataset = sample_dataset,\n", + " feature_keys = [\"signal\"],\n", + " label_key = \"labels\",\n", + " mode = \"multilabel\",\n", + ")\n", + "\n", + "# ── Model A: SparcNet (PyHealth built-in) ─────────────────────────────────────\n", + "sparcnet = SparcNet(**_common)\n", + "n_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", + "\n", + "# ── Model B: BiLSTMECG (paper best: d1_h64) ───────────────────────────────────\n", + "bilstm = BiLSTMECG(**_common, hidden_size=64, n_layers=1)\n", + "n_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", + "\n", + "# ── Model C: SE-ResNet-50 (proposed, paper-aligned) ───────────────────────────\n", + "# Best paper config: lr=0.01, batch=64 (grid search Table 5a, Appendix A.3)\n", + "# Architecture: ResNet-50 1D + SE blocks + backbone_out=256 + dropout=0.5\n", + "se_resnet = SEResNetECG(\n", + " **_common,\n", + " layers = [3, 4, 6, 3], # SE-ResNet-50\n", + " se_reduction = 16,\n", + " backbone_out = 256,\n", + " dropout = 0.5,\n", + ")\n", + "n_se_resnet = sum(p.numel() for p in se_resnet.parameters() if p.requires_grad)\n", + "\n", + "# ── Summary table ─────────────────────────────────────────────────────────────\n", + "print(\"=\" * 68)\n", + "print(\" MODEL SUMMARY\")\n", + "print(\"=\" * 68)\n", + "print(f\" {'Model':<20} {'Params':>10} {'Architecture'}\")\n", + "print(\" \" + \"─\" * 62)\n", + "print(f\" {'SparcNet':<20} {n_sparcnet:>10,} DenseNet-inspired 1D TCN (PyHealth)\")\n", + "print(f\" {'BiLSTMECG (d1_h64)':<20} {n_bilstm:>10,} Bidirectional LSTM, 1 layer, h=64\")\n", + "print(f\" {'SE-ResNet-50':<20} {n_se_resnet:>10,} ResNet-50 1D + SE blocks (proposed)\")\n", + "print(\"=\" * 68)\n", + "print(f\"\\n Input : (B, 12, 1000) — 12 leads × 1000 samples @ 100 Hz\")\n", + "print(f\" Output : (B, {len(SUPERDIAG_CLASSES)}) — {SUPERDIAG_CLASSES}\")\n", + "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", + "\n", + "# Smoke test — verify all three models run a forward pass\n", + "test_batch = next(iter(train_loader))\n", + "with torch.no_grad():\n", + " out_s = sparcnet(**test_batch)\n", + " out_b = bilstm(**test_batch)\n", + " out_se = se_resnet(**test_batch)\n", + "print(f\"\\nSmoke test (batch={BATCH_SIZE}):\")\n", + "print(f\" SparcNet logit={tuple(out_s['logit'].shape)} loss={out_s['loss'].item():.4f}\")\n", + "print(f\" BiLSTMECG logit={tuple(out_b['logit'].shape)} loss={out_b['loss'].item():.4f}\")\n", + "print(f\" SE-ResNet logit={tuple(out_se['logit'].shape)} loss={out_se['loss'].item():.4f}\")\n", + "print(\"\\n✅ All three models forward pass successful.\")" + ] + }, + { + "cell_type": "markdown", + "id": "fe927e41", + "metadata": {}, + "source": [ + "---\n", + "## Cell 6 — Train SE-ResNet-50\n", + "\n", + "Paper best config: **lr = 0.01**, batch = 64 (grid search Table 5a). \n", + "We use batch=32 here to match the baselines. Change `TRAIN_EPOCHS` for\n", + "publication-quality convergence (paper uses 250 with early stopping)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0213d64", + "metadata": {}, + "outputs": [], + "source": [ + "TRAIN_EPOCHS = 3 # ⚡ ultra-fast test; change to 25+ for quality results\n", + "SE_RESNET_LR = 0.01 # paper best hyperparameter (grid search Table 5a)\n", + "\n", + "print(\"=\" * 60)\n", + "print(f\" Training SE-ResNet-50 [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", + "print(f\" lr = {SE_RESNET_LR} (paper best from grid search)\")\n", + "print(\"=\" * 60)\n", + "\n", + "trainer_se = Trainer(\n", + " model = se_resnet,\n", + " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", + " enable_logging = True,\n", + " output_path = \"./output/se_resnet\",\n", + " exp_name = \"seresnet50_superdiag_5class\",\n", + ")\n", + "\n", + "trainer_se.train(\n", + " train_dataloader = train_loader,\n", + " val_dataloader = val_loader,\n", + " epochs = TRAIN_EPOCHS,\n", + " optimizer_params = {\"lr\": SE_RESNET_LR},\n", + " weight_decay = 1e-4,\n", + " monitor = \"roc_auc_macro\",\n", + " monitor_criterion = \"max\",\n", + " load_best_model_at_last = True,\n", + ")\n", + "\n", + "print(\"\\nSE-ResNet-50 training complete.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3173705b", + "metadata": {}, + "source": [ + "---\n", + "## Cell 7 — Evaluate SE-ResNet-50" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6592fde2", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"=\" * 60)\n", + "print(\" SE-ResNet-50 — Test Set Evaluation\")\n", + "print(\"=\" * 60)\n", + "\n", + "se_scores = trainer_se.evaluate(test_loader)\n", + "print(f\"\\n Test ROC-AUC (macro) : {se_scores['roc_auc_macro']:.4f}\")\n", + "print(f\" Test F1 (macro) : {se_scores['f1_macro']:.4f}\")\n", + "print(f\" Test Loss : {se_scores['loss']:.4f}\")\n", + "\n", + "# Per-class breakdown\n", + "y_true_se, y_prob_se, _ = trainer_se.inference(test_loader)\n", + "\n", + "per_class_auc_se = {}\n", + "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", + " col = y_true_se[:, k]\n", + " if col.sum() > 0 and (1 - col).sum() > 0:\n", + " per_class_auc_se[cls] = roc_auc_score(col, y_prob_se[:, k])\n", + " else:\n", + " per_class_auc_se[cls] = float(\"nan\")\n", + "\n", + "print(f\"\\n Per-class ROC-AUC:\")\n", + "for cls, auc in per_class_auc_se.items():\n", + " bar = \"█\" * int((auc if not np.isnan(auc) else 0) * 20)\n", + " tag = f\"{auc:.4f}\" if not np.isnan(auc) else \" N/A\"\n", + " print(f\" {cls:<6} {tag} {bar}\")\n", + "\n", + "# ROC curves\n", + "colors = [\"#e74c3c\", \"#3498db\", \"#2ecc71\", \"#f39c12\", \"#9b59b6\"]\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "for k, (cls, color) in enumerate(zip(SUPERDIAG_CLASSES, colors)):\n", + " col = y_true_se[:, k]\n", + " if col.sum() > 0 and (1-col).sum() > 0:\n", + " fpr, tpr, _ = roc_curve(col, y_prob_se[:, k])\n", + " axes[0].plot(fpr, tpr, color=color, lw=1.8,\n", + " label=f\"{cls} (AUC={per_class_auc_se[cls]:.3f})\")\n", + "axes[0].plot([0,1],[0,1],\"k--\",lw=1,alpha=0.5,label=\"Random\")\n", + "axes[0].set_title(\"SE-ResNet-50 — Per-class ROC Curves\", fontweight=\"bold\")\n", + "axes[0].set_xlabel(\"False Positive Rate\"); axes[0].set_ylabel(\"True Positive Rate\")\n", + "axes[0].legend(fontsize=9)\n", + "\n", + "per_class_f1_se = {}\n", + "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", + " col = y_true_se[:, k]\n", + " pred = (y_prob_se[:, k] >= 0.5).astype(int)\n", + " per_class_f1_se[cls] = f1_score(col, pred, zero_division=0)\n", + "axes[1].bar(SUPERDIAG_CLASSES, [per_class_f1_se[c] for c in SUPERDIAG_CLASSES],\n", + " color=colors, edgecolor=\"white\")\n", + "for i, (cls, sc) in enumerate(per_class_f1_se.items()):\n", + " axes[1].text(i, sc+0.01, f\"{sc:.3f}\", ha=\"center\", fontsize=9)\n", + "axes[1].set_ylim(0, 1.15)\n", + "axes[1].set_title(\"SE-ResNet-50 — Per-class F1 Score\", fontweight=\"bold\")\n", + "axes[1].set_ylabel(\"F1 Score\")\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f5f6b286", + "metadata": {}, + "source": [ + "---\n", + "## Cell 8 — Train baseline models (SparcNet + BiLSTMECG)\n", + "\n", + "Identical training setup as `ptbxl_pyhealth_pipeline.ipynb` for fair comparison." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7160144", + "metadata": {}, + "outputs": [], + "source": [ + "BASELINE_LR = 1e-3 # matches main pipeline\n", + "\n", + "# ── SparcNet ──────────────────────────────────────────────────────────────────\n", + "print(\"=\" * 60)\n", + "print(f\" Training SparcNet [{TRAIN_EPOCHS} epochs, N={len(tr_idx)}]\")\n", + "print(\"=\" * 60)\n", + "\n", + "trainer_sparcnet = Trainer(\n", + " model=sparcnet, metrics=[\"roc_auc_macro\", \"f1_macro\"],\n", + " enable_logging=True, output_path=\"./output/se_resnet\",\n", + " exp_name=\"sparcnet_cmp_superdiag_5class\",\n", + ")\n", + "trainer_sparcnet.train(\n", + " train_dataloader=train_loader, val_dataloader=val_loader,\n", + " epochs=TRAIN_EPOCHS, optimizer_params={\"lr\": BASELINE_LR},\n", + " weight_decay=1e-4, monitor=\"roc_auc_macro\", monitor_criterion=\"max\",\n", + " load_best_model_at_last=True,\n", + ")\n", + "sparcnet_scores = trainer_sparcnet.evaluate(test_loader)\n", + "print(f\"\\n SparcNet AUC={sparcnet_scores['roc_auc_macro']:.4f} \"\n", + " f\"F1={sparcnet_scores['f1_macro']:.4f}\")\n", + "\n", + "# ── BiLSTMECG ─────────────────────────────────────────────────────────────────\n", + "print()\n", + "print(\"=\" * 60)\n", + "print(f\" Training BiLSTMECG [{TRAIN_EPOCHS} epochs, N={len(tr_idx)}]\")\n", + "print(\"=\" * 60)\n", + "\n", + "trainer_bilstm = Trainer(\n", + " model=bilstm, metrics=[\"roc_auc_macro\", \"f1_macro\"],\n", + " enable_logging=True, output_path=\"./output/se_resnet\",\n", + " exp_name=\"bilstm_cmp_superdiag_5class\",\n", + ")\n", + "trainer_bilstm.train(\n", + " train_dataloader=train_loader, val_dataloader=val_loader,\n", + " epochs=TRAIN_EPOCHS, optimizer_params={\"lr\": BASELINE_LR},\n", + " weight_decay=1e-4, monitor=\"roc_auc_macro\", monitor_criterion=\"max\",\n", + " load_best_model_at_last=True,\n", + ")\n", + "bilstm_scores = trainer_bilstm.evaluate(test_loader)\n", + "print(f\"\\n BiLSTMECG AUC={bilstm_scores['roc_auc_macro']:.4f} \"\n", + " f\"F1={bilstm_scores['f1_macro']:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c817dc4d", + "metadata": {}, + "source": [ + "---\n", + "## Cell 9 — Three-model comparative results\n", + "\n", + "Side-by-side ROC-AUC and F1 comparison of all three models on the same\n", + "test set, with per-class bar charts for SE-ResNet." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0399ad75", + "metadata": {}, + "outputs": [], + "source": [ + "# ── Summary table ─────────────────────────────────────────────────────────────\n", + "all_scores = {\n", + " \"SparcNet\": sparcnet_scores,\n", + " \"BiLSTMECG\": bilstm_scores,\n", + " \"SE-ResNet-50\": se_scores,\n", + "}\n", + "model_colors = {\"SparcNet\": \"#2196F3\", \"BiLSTMECG\": \"#FF5722\", \"SE-ResNet-50\": \"#4CAF50\"}\n", + "\n", + "print(\"\\n\" + \"=\" * 68)\n", + "print(\" COMPARATIVE RESULTS — 3-Model Ablation\")\n", + "print(f\" Dataset : PTB-XL superdiagnostic (5 classes), N={N_SUBSAMPLE:,}\")\n", + "print(f\" Protocol : Patient-level 80/10/10 split, seed=42, {TRAIN_EPOCHS} epochs\")\n", + "print(\"=\" * 68)\n", + "print(f\" {'Model':<20} {'ROC-AUC (macro)':>15} {'F1 (macro)':>10} {'Loss':>8}\")\n", + "print(\" \" + \"─\" * 60)\n", + "for model_name, sc in all_scores.items():\n", + " auc = sc.get(\"roc_auc_macro\", float(\"nan\"))\n", + " f1 = sc.get(\"f1_macro\", float(\"nan\"))\n", + " loss = sc.get(\"loss\", float(\"nan\"))\n", + " print(f\" {model_name:<20} {auc:>15.4f} {f1:>10.4f} {loss:>8.4f}\")\n", + "print(\"=\" * 68)\n", + "\n", + "auc_vals = [sparcnet_scores[\"roc_auc_macro\"], bilstm_scores[\"roc_auc_macro\"],\n", + " se_scores[\"roc_auc_macro\"]]\n", + "f1_vals = [sparcnet_scores[\"f1_macro\"], bilstm_scores[\"f1_macro\"],\n", + " se_scores[\"f1_macro\"]]\n", + "best = list(all_scores.keys())[int(np.argmax(auc_vals))]\n", + "print(f\"\\n Best model by ROC-AUC : {best}\")\n", + "\n", + "# ── Comparative bar charts ────────────────────────────────────────────────────\n", + "model_names = [\"SparcNet\", \"BiLSTMECG\", \"SE-ResNet-50\"]\n", + "colors_list = [model_colors[m] for m in model_names]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "fig.suptitle(\n", + " f\"3-Model Comparison: SparcNet vs BiLSTMECG vs SE-ResNet-50\\n\"\n", + " f\"PTB-XL superdiagnostic (5 classes) | N={N_SUBSAMPLE:,} samples | \"\n", + " f\"{TRAIN_EPOCHS} epochs\",\n", + " fontsize=11, fontweight=\"bold\"\n", + ")\n", + "\n", + "x = np.arange(len(model_names))\n", + "axes[0].bar(x, auc_vals, color=colors_list, edgecolor=\"white\", width=0.55)\n", + "axes[0].axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=1, label=\"Random\")\n", + "for i, (m, v) in enumerate(zip(model_names, auc_vals)):\n", + " axes[0].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=10, fontweight=\"bold\")\n", + "axes[0].set_xticks(x); axes[0].set_xticklabels(model_names, rotation=10)\n", + "axes[0].set_ylim(0, 1.0); axes[0].set_ylabel(\"ROC-AUC (macro)\", fontsize=11)\n", + "axes[0].set_title(\"Test ROC-AUC\", fontweight=\"bold\")\n", + "axes[0].legend(fontsize=9)\n", + "\n", + "axes[1].bar(x, f1_vals, color=colors_list, edgecolor=\"white\", width=0.55)\n", + "for i, (m, v) in enumerate(zip(model_names, f1_vals)):\n", + " axes[1].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=10, fontweight=\"bold\")\n", + "axes[1].set_xticks(x); axes[1].set_xticklabels(model_names, rotation=10)\n", + "axes[1].set_ylim(0, 1.0); axes[1].set_ylabel(\"F1 Score (macro)\", fontsize=11)\n", + "axes[1].set_title(\"Test F1 Score\", fontweight=\"bold\")\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"ptbxl_3model_comparison.png\", dpi=150, bbox_inches=\"tight\")\n", + "plt.show()\n", + "print(\"\\nFigure saved → ptbxl_3model_comparison.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "a112e83e", + "metadata": {}, + "source": [ + "---\n", + "## Cell 10 — Per-class comparison across all three models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98d771cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Collect per-class AUC for all models\n", + "y_true_sn, y_prob_sn, _ = trainer_sparcnet.inference(test_loader)\n", + "y_true_bl, y_prob_bl, _ = trainer_bilstm.inference(test_loader)\n", + "# SE-ResNet inference already done (y_true_se, y_prob_se)\n", + "\n", + "all_inferences = {\n", + " \"SparcNet\": (y_true_sn, y_prob_sn),\n", + " \"BiLSTMECG\": (y_true_bl, y_prob_bl),\n", + " \"SE-ResNet-50\": (y_true_se, y_prob_se),\n", + "}\n", + "\n", + "# Build per-class AUC table\n", + "per_class_auc_all = {}\n", + "for model_name, (y_true, y_prob) in all_inferences.items():\n", + " per_class_auc_all[model_name] = {}\n", + " for k, cls in enumerate(SUPERDIAG_CLASSES):\n", + " col = y_true[:, k]\n", + " if col.sum() > 0 and (1 - col).sum() > 0:\n", + " per_class_auc_all[model_name][cls] = roc_auc_score(col, y_prob[:, k])\n", + " else:\n", + " per_class_auc_all[model_name][cls] = float(\"nan\")\n", + "\n", + "# Print table\n", + "print(\"Per-class ROC-AUC:\")\n", + "print(f\" {'Class':<8}\", end=\"\")\n", + "for m in all_inferences.keys():\n", + " print(f\" {m:>14}\", end=\"\")\n", + "print()\n", + "print(\" \" + \"─\" * 54)\n", + "for cls in SUPERDIAG_CLASSES:\n", + " print(f\" {cls:<8}\", end=\"\")\n", + " for m in all_inferences.keys():\n", + " v = per_class_auc_all[m][cls]\n", + " print(f\" {v:>14.4f}\" if not np.isnan(v) else f\" {' N/A':>14}\", end=\"\")\n", + " print()\n", + "\n", + "# Grouped bar chart per class\n", + "x = np.arange(len(SUPERDIAG_CLASSES))\n", + "w = 0.25\n", + "fig, ax = plt.subplots(figsize=(12, 5))\n", + "for i, (model_name, color) in enumerate(model_colors.items()):\n", + " vals = [per_class_auc_all[model_name][cls] for cls in SUPERDIAG_CLASSES]\n", + " vals = [0 if np.isnan(v) else v for v in vals]\n", + " ax.bar(x + (i - 1) * w, vals, width=w, label=model_name, color=color, edgecolor=\"white\")\n", + "\n", + "ax.set_xticks(x); ax.set_xticklabels(SUPERDIAG_CLASSES)\n", + "ax.set_ylim(0, 1.1); ax.set_ylabel(\"ROC-AUC\", fontsize=11)\n", + "ax.set_title(\"Per-class ROC-AUC: SparcNet vs BiLSTMECG vs SE-ResNet-50\",\n", + " fontweight=\"bold\")\n", + "ax.axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=0.8, label=\"Random\")\n", + "ax.legend(fontsize=9)\n", + "plt.tight_layout()\n", + "plt.savefig(\"ptbxl_per_class_auc_3model.png\", dpi=150, bbox_inches=\"tight\")\n", + "plt.show()\n", + "print(\"Figure saved → ptbxl_per_class_auc_3model.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "300cd407", + "metadata": {}, + "source": [ + "---\n", + "## Cell 11 — Reproducibility checklist" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7804f255", + "metadata": {}, + "outputs": [], + "source": [ + "import sys, torch, numpy, sklearn, pandas\n", + "\n", + "print(\"=\" * 60)\n", + "print(\" REPRODUCIBILITY CHECKLIST\")\n", + "print(\"=\" * 60)\n", + "print(f\" Python : {sys.version.split()[0]}\")\n", + "print(f\" PyTorch : {torch.__version__}\")\n", + "print(f\" NumPy : {numpy.__version__}\")\n", + "print(f\" scikit-learn : {sklearn.__version__}\")\n", + "print(f\" pandas : {pandas.__version__}\")\n", + "print(\"-\" * 60)\n", + "print(f\" Random seed : 42\")\n", + "print(f\" N_SUBSAMPLE : {N_SUBSAMPLE:,}\")\n", + "print(f\" TRAIN_EPOCHS : {TRAIN_EPOCHS}\")\n", + "print(f\" Batch size : {BATCH_SIZE} (SE-ResNet paper best: 64)\")\n", + "print(f\" SE-ResNet LR : {SE_RESNET_LR} (paper best from grid search Table 5a)\")\n", + "print(f\" Baseline LR : {BASELINE_LR}\")\n", + "print(f\" Split : 80/10/10 patient-level\")\n", + "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", + "print(f\" Metrics : ROC-AUC macro, F1 macro (thr=0.5)\")\n", + "print(f\" Device : {DEVICE}\")\n", + "print(\"=\" * 60)\n", + "print()\n", + "print(\" SE-ResNet-50 architecture (se_resnet_ecg.py):\")\n", + "print(f\" layers = [3, 4, 6, 3] (ResNet-50)\")\n", + "print(f\" se_reduction = 16 (SE-Net paper default)\")\n", + "print(f\" backbone_out = 256 (per paper: all backbones output 256)\")\n", + "print(f\" dropout = 0.5\")\n", + "print()\n", + "print(\" Reference:\")\n", + "print(\" Nonaka & Seita (2021). In-depth Benchmarking of Deep Neural\")\n", + "print(\" Network Architectures for ECG Diagnosis. MLHC 2021.\")\n", + "print(\"=\" * 60)\n", + "print(\"\\n✅ This notebook is self-contained.\")" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyhealth/models/__init__.py b/pyhealth/models/__init__.py index 5233b1726..afa6b11a9 100644 --- a/pyhealth/models/__init__.py +++ b/pyhealth/models/__init__.py @@ -1,6 +1,7 @@ from .adacare import AdaCare, AdaCareLayer, MultimodalAdaCare from .agent import Agent, AgentLayer from .base_model import BaseModel +from .bilstm_ecg import BiLSTMECG from .biot import BIOT from .cnn import CNN, CNNLayer from .concare import ConCare, ConCareLayer diff --git a/pyhealth/models/bilstm_ecg.py b/pyhealth/models/bilstm_ecg.py new file mode 100644 index 000000000..a501735af --- /dev/null +++ b/pyhealth/models/bilstm_ecg.py @@ -0,0 +1,192 @@ +"""Bidirectional LSTM for 12-lead ECG multi-label classification. + +This module provides :class:`BiLSTMECG`, a :class:`~pyhealth.models.BaseModel` +subclass implementing the Bidirectional LSTM architecture benchmarked in: + + Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural + Network Architectures for ECG Diagnosis.* Proceedings of Machine Learning + Research 126:1–19, MLHC 2021. + +The paper's best-performing LSTM variant (``lstm_d1_h64``) uses a **single +bidirectional LSTM layer** with ``hidden_size=64``, producing 128-dimensional +hidden states that are projected to the output head. This implementation +follows the same design but exposes ``hidden_size`` and ``n_layers`` as +constructor arguments so it can be used as a drop-in replacement across the +full ablation grid. + +Mathematical framing +-------------------- +Given an ECG tensor :math:`X \\in \\mathbb{R}^{B \\times C \\times T}` (batch +size :math:`B`, :math:`C=12` leads, :math:`T` time-steps), the model: + +1. Permutes to :math:`(B, T, C)` for sequence-first processing. +2. Passes through a bidirectional LSTM: + + .. math:: + + h_t = \\text{BiLSTM}(x_t, h_{t-1})\\quad h_t \\in \\mathbb{R}^{B \\times 2H} + +3. Takes the **last** time-step output :math:`h_T \\in \\mathbb{R}^{B \\times 2H}`. +4. Projects with a linear head :math:`W \\in \\mathbb{R}^{2H \\times K}` to produce + logits for :math:`K` classes. +5. Optimises with **binary cross-entropy with logits** (multi-label): + + .. math:: + + \\mathcal{L} = -\\frac{1}{K}\\sum_{k=1}^{K} + \\bigl[y_k \\log \\sigma(\\hat{y}_k) + + (1-y_k)\\log(1-\\sigma(\\hat{y}_k))\\bigr] + +Paper alignment +--------------- ++------------+----------------------------+---------------------------+ +| Paper name | Paper setting | Default in this class | ++============+============================+===========================+ +| lstm_d1_h64| 1 layer, hidden=64 | n_layers=1, hidden_size=64| ++------------+----------------------------+---------------------------+ +| lstm_d3_h128| 3 layers, hidden=128 | n_layers=3, hidden_size=128| ++------------+----------------------------+---------------------------+ + +Signal format expected +---------------------- +``feature_keys=["signal"]`` → each batch element is a ``np.ndarray`` of shape +``(12, T)`` loaded by ``SampleSignalDataset`` from a ``.pkl`` file. :math:`T` +is typically 1000 at 100 Hz or 5000 at 500 Hz. + +Author: + CS-598 DLH Project Team — PyHealth contribution +""" + +from typing import List, Optional + +import numpy as np +import torch +import torch.nn as nn + +from pyhealth.models import BaseModel + + +class BiLSTMECG(BaseModel): + """Bidirectional LSTM ECG classifier. + + Extends :class:`~pyhealth.models.BaseModel` so it integrates seamlessly + with :class:`~pyhealth.trainer.Trainer`, :class:`~pyhealth.datasets.PTBXLDataset`, + and :func:`~pyhealth.metrics.multilabel_metrics_fn`. + + Args: + dataset: A PyHealth ``SampleSignalDataset`` (or ``Subset``) that + exposes ``input_info`` with ``"signal"`` → ``{"n_channels": 12}``. + feature_keys (List[str]): Must be ``["signal"]``. + label_key (str): Key in the sample dict that holds the label list. + Use ``"labels"`` to match ``PTBXLMultilabelClassification`` output. + mode (str): ``"multilabel"`` applies ``BCEWithLogitsLoss``; other modes + are passed through to :class:`~pyhealth.models.BaseModel`. + hidden_size (int): LSTM hidden dimension *per direction*. The + bidirectional output is ``2 × hidden_size``. Paper best variant + uses ``hidden_size=64`` (1 layer). Defaults to ``64``. + n_layers (int): Number of stacked LSTM layers. Paper uses ``1``. + Defaults to ``1``. + dropout (float): Dropout probability applied between LSTM layers + when ``n_layers > 1``. Defaults to ``0.2``. + + Examples: + Paper-aligned variant (lstm_d1_h64):: + + >>> from pyhealth.models import BiLSTMECG + >>> model = BiLSTMECG( + ... dataset=sample_dataset, + ... feature_keys=["signal"], + ... label_key="labels", + ... mode="multilabel", + ... hidden_size=64, + ... n_layers=1, + ... ) + + Deeper variant used in ablation grid:: + + >>> model_deep = BiLSTMECG( + ... dataset=sample_dataset, + ... feature_keys=["signal"], + ... label_key="labels", + ... mode="multilabel", + ... hidden_size=128, + ... n_layers=3, + ... ) + """ + + def __init__( + self, + dataset, + feature_keys: List[str], + label_key: str, + mode: str, + hidden_size: int = 64, + n_layers: int = 1, + dropout: float = 0.2, + **kwargs, + ): + super().__init__( + dataset=dataset, + feature_keys=feature_keys, + label_key=label_key, + mode=mode, + ) + + sig_info = self.dataset.input_info["signal"] + in_channels: int = sig_info["n_channels"] # 12 for standard 12-lead ECG + + self.label_tokenizer = self.get_label_tokenizer() + output_size: int = self.get_output_size(self.label_tokenizer) + + # ── Bidirectional LSTM ──────────────────────────────────────────────── + # Input: (B, T, C) after permute + # Output: (B, T, hidden_size * 2) — bidirectional concatenation + self.lstm = nn.LSTM( + input_size=in_channels, + hidden_size=hidden_size, + num_layers=n_layers, + bidirectional=True, + batch_first=True, + dropout=dropout if n_layers > 1 else 0.0, + ) + + # ── Projection head ─────────────────────────────────────────────────── + # Pool over all time-steps: AdaptiveAvgPool1d(1) → (B, hidden_size*2) + self.pool = nn.AdaptiveAvgPool1d(1) + self.fc = nn.Linear(hidden_size * 2, output_size) + + # ------------------------------------------------------------------ + def forward(self, **kwargs) -> dict: # type: ignore[override] + """Forward pass. + + Keyword args are the collated batch dict from the DataLoader. + The key ``self.feature_keys[0]`` (``"signal"``) holds a list of + ``np.ndarray`` of shape ``(12, T)``. + + Returns: + dict with keys ``"loss"``, ``"y_prob"``, ``"y_true"``, + ``"logit"`` — the standard PyHealth model output contract. + """ + # Stack list[(12,T)] → tensor (B, 12, T) + x = torch.tensor( + np.array(kwargs[self.feature_keys[0]]), + device=self.device, + ).float() + + # (B, 12, T) → (B, T, 12) for sequence-first LSTM with batch_first=True + out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2) + # (B, T, hidden*2) → (B, hidden*2, T) → pool → (B, hidden*2) + # Matches paper bi_lstm.py: AdaptiveAvgPool1d over ALL timesteps + pooled = self.pool(out.permute(0, 2, 1)).squeeze(-1) # (B, hidden*2) + logits = self.fc(pooled) # (B, K) + + y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer) + loss = self.get_loss_function()(logits, y_true) + y_prob = self.prepare_y_prob(logits) + + return { + "loss": loss, + "y_prob": y_prob, + "y_true": y_true, + "logit": logits, + } From a0b3302cb1b7d5a6a14fd5af169935c4f5c4a20b Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sat, 18 Apr 2026 20:03:53 -0700 Subject: [PATCH 05/10] moved SEResNetECG to pyhealth/models/ and export from _init__ --- pyhealth/models/__init__.py | 1 + {cs598_project => pyhealth/models}/se_resnet_ecg.py | 0 2 files changed, 1 insertion(+) rename {cs598_project => pyhealth/models}/se_resnet_ecg.py (100%) diff --git a/pyhealth/models/__init__.py b/pyhealth/models/__init__.py index afa6b11a9..9a959f6aa 100644 --- a/pyhealth/models/__init__.py +++ b/pyhealth/models/__init__.py @@ -2,6 +2,7 @@ from .agent import Agent, AgentLayer from .base_model import BaseModel from .bilstm_ecg import BiLSTMECG +from .se_resnet_ecg import SEResNetECG, SEBlock1D, Bottleneck1D from .biot import BIOT from .cnn import CNN, CNNLayer from .concare import ConCare, ConCareLayer diff --git a/cs598_project/se_resnet_ecg.py b/pyhealth/models/se_resnet_ecg.py similarity index 100% rename from cs598_project/se_resnet_ecg.py rename to pyhealth/models/se_resnet_ecg.py From a0f8a0f2d54529ce3f044fb77f4e02285c016d76 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 19 Apr 2026 00:30:57 -0700 Subject: [PATCH 06/10] Align task with load_data() columns and split task tests into test_ptbxl_task --- .../tasks/ptbxl_multilabel_classification.py | 19 +- tests/core/test_ptbxl_task.py | 289 ++++++++++++++++++ 2 files changed, 302 insertions(+), 6 deletions(-) create mode 100644 tests/core/test_ptbxl_task.py diff --git a/pyhealth/tasks/ptbxl_multilabel_classification.py b/pyhealth/tasks/ptbxl_multilabel_classification.py index e8934fd93..fb2f29dc2 100644 --- a/pyhealth/tasks/ptbxl_multilabel_classification.py +++ b/pyhealth/tasks/ptbxl_multilabel_classification.py @@ -208,7 +208,7 @@ class PTBXLMultilabelClassification(BaseTask): 1. Loads the ``.mat`` signal matrix via :func:`scipy.io.loadmat` (shape ``(12, 5000)`` at 500 Hz). 2. Optionally decimates the signal to 100 Hz (shape ``(12, 1000)``). - 3. Parses SNOMED-CT codes from the ``scp_codes`` event attribute. + 3. Parses SNOMED-CT codes from the ``dx_codes`` event attribute. 4. Maps those codes to the chosen label space (superdiagnostic or full Challenge 27-class). 5. Returns one sample dict per valid recording:: @@ -297,7 +297,10 @@ def __call__(self, patient: Patient) -> List[Dict]: Args: patient: A :class:`~pyhealth.data.Patient` object whose events have ``event_type="ptbxl"`` and carry attributes - ``signal_file``, ``scp_codes``, ``age``, and ``sex``. + ``mat``, ``dx_codes``, ``age``, and ``sex``. + These map from ``load_data()`` columns ``ptbxl/mat`` and + ``ptbxl/dx_codes`` (the ``ptbxl/`` prefix is stripped by + :meth:`~pyhealth.data.Event.from_dict`). Returns: A list with at most one sample dict @@ -312,9 +315,11 @@ def __call__(self, patient: Patient) -> List[Dict]: for event in events: # ---- 1. Load the .mat signal -------------------------------- - signal_file = getattr(event, "signal_file", None) + # Column "ptbxl/mat" in load_data() → attribute "mat" on the event + # (the "ptbxl/" table prefix is stripped by Event.from_dict). + signal_file = getattr(event, "mat", None) if not signal_file: - logger.debug("Skip %s: no signal_file attribute.", event) + logger.debug("Skip %s: no mat attribute.", event) continue try: @@ -340,8 +345,10 @@ def __call__(self, patient: Patient) -> List[Dict]: signal = signal[:, ::5] # shape (12, 1000) # ---- 3. Parse SNOMED-CT codes -------------------------------- - raw_codes: str = str(getattr(event, "scp_codes", "") or "") - codes = [c.strip() for c in raw_codes.split(",") if c.strip()] + # Column "ptbxl/dx_codes" → attribute "dx_codes"; values are + # dot-joined by load_data() via ".".join(dx), so split on ".". + raw_codes: str = str(getattr(event, "dx_codes", "") or "") + codes = [c.strip() for c in raw_codes.split(".") if c.strip()] # ---- 4. Map to chosen label space --------------------------- if self.label_type == "superdiagnostic": diff --git a/tests/core/test_ptbxl_task.py b/tests/core/test_ptbxl_task.py new file mode 100644 index 000000000..1bc792d07 --- /dev/null +++ b/tests/core/test_ptbxl_task.py @@ -0,0 +1,289 @@ +"""Unit tests for PTBXLMultilabelClassification task. + +Test strategy +------------- +* All tests are self-contained and run fully offline — no network calls, no + real ECG data required. +* Synthetic in-memory ECG arrays are written to temporary ``.mat`` files via + ``scipy.io.savemat`` so that the task's ``loadmat`` call round-trips cleanly. +* ``_FakeEvent`` mirrors the event attributes produced by + ``PTBXLDataset.load_data()``: ``mat`` (file path) and ``dx_codes`` + (SNOMED-CT codes joined by ``"."``). +* Both ``label_type`` variants (``"superdiagnostic"`` / ``"diagnostic"``) and + both ``sampling_rate`` values (100 / 500) are exercised. + +Author: + CS-598 DLH Project Team +""" + +import tempfile +import unittest +from dataclasses import dataclass +from pathlib import Path +from typing import List + +import numpy as np + +from pyhealth.tasks.ptbxl_multilabel_classification import ( + CHALLENGE_SNOMED_CLASSES, + SNOMED_TO_SUPERDIAG, + SUPERDIAG_CLASSES, + PTBXLMultilabelClassification, +) + + +# --------------------------------------------------------------------------- +# Fake Patient / Event +# --------------------------------------------------------------------------- + +@dataclass +class _FakeEvent: + """Minimal stand-in for a PyHealth Event with PTB-XL attributes. + + Attribute names match what PTBXLDataset.load_data() produces after the + ``ptbxl/`` table-prefix is stripped by BaseDataset: + - ``mat`` ← column ``ptbxl/mat`` (path to .mat signal file) + - ``dx_codes`` ← column ``ptbxl/dx_codes`` (SNOMED codes, dot-joined) + """ + mat: str = "" + dx_codes: str = "" + age: int = 50 + sex: str = "Male" + + +class _FakePatient: + def __init__(self, patient_id: str, events: List[_FakeEvent]): + self.patient_id = patient_id + self._events = events + + def get_events(self, event_type: str = None) -> List[_FakeEvent]: + return self._events + + +# --------------------------------------------------------------------------- +# Task unit tests +# --------------------------------------------------------------------------- + +class TestPTBXLMultilabelClassification(unittest.TestCase): + """Test PTBXLMultilabelClassification.__call__ with synthetic ECG data.""" + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def _make_mat_file(self, tmp_dir: Path, name: str, signal: np.ndarray) -> str: + """Write a scipy .mat file containing 'val' and return its path.""" + import scipy.io + path = tmp_dir / name + scipy.io.savemat(str(path), {"val": signal}) + return str(path) + + def _make_patient(self, mat_path: str, dx_codes: str) -> _FakePatient: + event = _FakeEvent(mat=mat_path, dx_codes=dx_codes) + return _FakePatient("p001", [event]) + + # ------------------------------------------------------------------ + # Constructor validation + # ------------------------------------------------------------------ + + def test_invalid_sampling_rate_raises(self): + with self.assertRaises(ValueError): + PTBXLMultilabelClassification(sampling_rate=250) + + def test_invalid_label_type_raises(self): + with self.assertRaises(ValueError): + PTBXLMultilabelClassification(label_type="morphological") + + def test_task_names_are_unique(self): + t_a = PTBXLMultilabelClassification(sampling_rate=100, label_type="superdiagnostic") + t_b = PTBXLMultilabelClassification(sampling_rate=500, label_type="superdiagnostic") + t_c = PTBXLMultilabelClassification(sampling_rate=100, label_type="diagnostic") + t_d = PTBXLMultilabelClassification(sampling_rate=500, label_type="diagnostic") + names = {t_a.task_name, t_b.task_name, t_c.task_name, t_d.task_name} + self.assertEqual(len(names), 4, "All four configurations should have distinct task names.") + + # ------------------------------------------------------------------ + # Signal loading and decimation + # ------------------------------------------------------------------ + + def test_superdiagnostic_100hz_signal_shape(self): + """Superdiagnostic task at 100 Hz should yield (12, 1000) signals.""" + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") # NORM + + task = PTBXLMultilabelClassification(sampling_rate=100, label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertEqual(samples[0]["signal"].shape, (12, 1000)) + + def test_superdiagnostic_500hz_signal_shape(self): + """Superdiagnostic task at 500 Hz should yield (12, 5000) signals (no decimation).""" + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") # NORM + + task = PTBXLMultilabelClassification(sampling_rate=500, label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertEqual(samples[0]["signal"].shape, (12, 5000)) + + def test_signal_dtype_is_float32(self): + with tempfile.TemporaryDirectory() as tmp: + signal_500 = np.random.randn(12, 5000).astype(np.float64) # 64-bit input + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal_500) + patient = self._make_patient(mat_path, "426783006") + + task = PTBXLMultilabelClassification() + samples = task(patient) + self.assertEqual(samples[0]["signal"].dtype, np.float32) + + # ------------------------------------------------------------------ + # Superdiagnostic label mapping + # ------------------------------------------------------------------ + + def test_superdiagnostic_normal_label(self): + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "426783006") # → NORM + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertIn("NORM", samples[0]["labels"]) + + def test_superdiagnostic_multilabel(self): + """A recording with both AF (CD) and low QRS voltage (HYP) codes.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + # 164889003 → CD (atrial fibrillation), 251146004 → HYP (low QRS voltage) + # dx_codes are dot-joined (load_data uses ".".join(dx)) + patient = self._make_patient(mat_path, "164889003.251146004") + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + label_set = set(samples[0]["labels"]) + self.assertIn("CD", label_set) + self.assertIn("HYP", label_set) + + def test_superdiagnostic_no_known_codes_skipped(self): + """Recordings with no recognised superdiagnostic codes should be skipped.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "999999999") # unknown code + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + # ------------------------------------------------------------------ + # Diagnostic (27-class) label mapping + # ------------------------------------------------------------------ + + def test_diagnostic_known_challenge_code(self): + # 270492004 = First-degree AV block, part of Challenge 2020 scoring set + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "270492004") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + self.assertIn("270492004", samples[0]["labels"]) + + def test_diagnostic_non_challenge_code_skipped(self): + """A code not in the 27-class Challenge vocabulary should be filtered out.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + patient = self._make_patient(mat_path, "999999999") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + def test_diagnostic_multiple_valid_codes(self): + """Multiple Challenge codes in one recording should all appear as labels.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((12, 5000), dtype=np.float32) + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + # 164889003 (AF) and 426783006 (NSR) are both in Challenge vocabulary + # dot-joined as produced by load_data() + patient = self._make_patient(mat_path, "164889003.426783006") + + task = PTBXLMultilabelClassification(label_type="diagnostic") + samples = task(patient) + + self.assertEqual(len(samples), 1) + label_set = set(samples[0]["labels"]) + self.assertIn("164889003", label_set) + self.assertIn("426783006", label_set) + + # ------------------------------------------------------------------ + # Edge cases + # ------------------------------------------------------------------ + + def test_missing_signal_file_returns_empty(self): + event = _FakeEvent(mat="", dx_codes="426783006") + patient = _FakePatient("p001", [event]) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_nonexistent_signal_file_returns_empty(self): + event = _FakeEvent(mat="/nonexistent/path/to/rec.mat", dx_codes="426783006") + patient = _FakePatient("p001", [event]) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_empty_patient_no_events(self): + patient = _FakePatient("p001", []) + task = PTBXLMultilabelClassification() + self.assertEqual(task(patient), []) + + def test_wrong_signal_shape_skipped(self): + """Signals that are not 2-D with 12 channels should be skipped.""" + with tempfile.TemporaryDirectory() as tmp: + signal = np.zeros((1, 5000), dtype=np.float32) # single-channel, not 12 + mat_path = self._make_mat_file(Path(tmp), "rec.mat", signal) + event = _FakeEvent(mat=mat_path, dx_codes="426783006") + patient = _FakePatient("p001", [event]) + + task = PTBXLMultilabelClassification(label_type="superdiagnostic") + samples = task(patient) + self.assertEqual(samples, []) + + # ------------------------------------------------------------------ + # Label-space constants sanity checks + # ------------------------------------------------------------------ + + def test_superdiag_classes_count(self): + self.assertEqual(len(SUPERDIAG_CLASSES), 5) + self.assertEqual(set(SUPERDIAG_CLASSES), {"NORM", "MI", "STTC", "CD", "HYP"}) + + def test_challenge_classes_count(self): + self.assertEqual(len(CHALLENGE_SNOMED_CLASSES), 27) + + def test_snomed_to_superdiag_values(self): + valid_classes = set(SUPERDIAG_CLASSES) + for code, cls in SNOMED_TO_SUPERDIAG.items(): + self.assertIn( + cls, + valid_classes, + f"SNOMED code {code} maps to unknown class '{cls}'", + ) + + +if __name__ == "__main__": + unittest.main() From c0e759c29c0352f43d1bb124f31f6723366a9d82 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 19 Apr 2026 00:43:23 -0700 Subject: [PATCH 07/10] remove: delete ptbxl.yaml config (superseded by load_data() pipeline) --- pyhealth/datasets/configs/ptbxl.yaml | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 pyhealth/datasets/configs/ptbxl.yaml diff --git a/pyhealth/datasets/configs/ptbxl.yaml b/pyhealth/datasets/configs/ptbxl.yaml deleted file mode 100644 index 3a9f5d9b4..000000000 --- a/pyhealth/datasets/configs/ptbxl.yaml +++ /dev/null @@ -1,13 +0,0 @@ -version: "1.0.0" - -tables: - ptbxl: - file_path: "ptbxl-pyhealth.csv" - patient_id: "patient_id" - timestamp: null - attributes: - - record_id - - signal_file - - age - - sex - - scp_codes From 79c80fea691186a56faa1f52e81638311405a05b Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 19 Apr 2026 01:14:04 -0700 Subject: [PATCH 08/10] remove: delete cs598_project tracked files from PR (jtwells2 review) --- cs598_project/PTBXLImplementation.md | 968 --- cs598_project/ptbxl_pyhealth_pipeline.ipynb | 7867 ------------------- cs598_project/se_resnet_ecg_pipeline.ipynb | 871 -- 3 files changed, 9706 deletions(-) delete mode 100644 cs598_project/PTBXLImplementation.md delete mode 100644 cs598_project/ptbxl_pyhealth_pipeline.ipynb delete mode 100644 cs598_project/se_resnet_ecg_pipeline.ipynb diff --git a/cs598_project/PTBXLImplementation.md b/cs598_project/PTBXLImplementation.md deleted file mode 100644 index 6b0588162..000000000 --- a/cs598_project/PTBXLImplementation.md +++ /dev/null @@ -1,968 +0,0 @@ -# PTB-XL ECG Classification — Complete Implementation Guide - -**Course:** CS-598 Deep Learning for Healthcare -**Project:** PTB-XL Dataset + Multi-Label Task integration into PyHealth 2.0 -**Stack:** Python ≥ 3.12 · PyTorch 2.7 · PyHealth 2.0 - ---- - -## Table of Contents - -1. [Project Overview](#1-project-overview) -2. [Repository File Map](#2-repository-file-map) -3. [PyHealth 5-Stage Pipeline](#3-pyhealth-5-stage-pipeline) -4. [Stage 1 — Dataset Implementation](#4-stage-1--dataset-implementation) - - 4.1 [YAML Config](#41-yaml-config-pyhealth.datasets.configs.ptbxl.yaml) - - 4.2 [PTBXLDataset Class](#42-ptbxldataset-class) - - 4.3 [prepare_metadata Flow](#43-preparemetadata-flow) - - 4.4 [Header Parsing](#44-header-parsing) - - 4.5 [Dataset → BaseDataset Sequence](#45-dataset--basedataset-sequence) -5. [Stage 2 — Task Implementation](#5-stage-2--task-implementation) - - 5.1 [Label Space Definitions](#51-label-space-definitions) - - 5.2 [PTBXLMultilabelClassification Class](#52-ptbxlmultilabelclassification-class) - - 5.3 [\_\_call\_\_ Flow per Patient](#53-__call__-flow-per-patient) - - 5.4 [Decimation: 500 Hz → 100 Hz](#54-decimation-500-hz--100-hz) -6. [Mathematical Framing](#6-mathematical-framing) - - 6.1 [Signal Representation](#61-signal-representation) - - 6.2 [Forward Pass](#62-forward-pass) - - 6.3 [Loss Function](#63-loss-function) - - 6.4 [Evaluation Metrics](#64-evaluation-metrics) -7. [Ablation Study Design](#7-ablation-study-design) -8. [Module Registration (\_\_init\_\_ imports)](#8-module-registration-__init__-imports) -9. [Documentation (RST + toctree)](#9-documentation-rst--toctree) -10. [Test Suite](#10-test-suite) - - 10.1 [Test Architecture](#101-test-architecture) - - 10.2 [Dataset Tests](#102-dataset-tests) - - 10.3 [Task Tests](#103-task-tests) -11. [Example Notebook — Ablation Study](#11-example-notebook--ablation-study) - - 11.1 [End-to-End Pipeline Sequence](#111-end-to-end-pipeline-sequence) -12. [Data Layout](#12-data-layout) -13. [Dependency Graph](#13-dependency-graph) -14. [References](#14-references) - ---- - -## 1. Project Overview - -PTB-XL is the largest openly available clinical 12-lead ECG dataset (21,837 recordings, 18,885 patients, Charité Hospital Berlin). This project integrates it fully into the **PyHealth 2.0** framework by implementing: - -| Deliverable | File | Purpose | -|---|---|---| -| Dataset class | `pyhealth/datasets/ptbxl.py` | Parse raw WFDB files into PyHealth patient records | -| YAML schema | `pyhealth/datasets/configs/ptbxl.yaml` | Tell BaseDataset which columns to load | -| Task class | `pyhealth/tasks/ptbxl_multilabel_classification.py` | Convert patient records to ML samples | -| Dataset RST | `docs/api/datasets/pyhealth.datasets.PTBXLDataset.rst` | Sphinx API doc for dataset | -| Task RST | `docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst` | Sphinx API doc for task | -| datasets.rst entry | `docs/api/datasets.rst` (line 241) | toctree link to dataset doc | -| tasks.rst entry | `docs/api/tasks.rst` (line 232) | toctree link to task doc | -| Test file | `tests/core/test_ptbxl.py` | 18 offline unit tests | -| Example notebook | `examples/ptbxl_superdiagnostic_sparcnet.ipynb` | Ablation study | - ---- - -## 2. Repository File Map - -``` -PyHealth/ -├── pyhealth/ -│ ├── datasets/ -│ │ ├── __init__.py ← imports PTBXLDataset -│ │ ├── ptbxl.py ← ★ Dataset implementation -│ │ ├── base_dataset.py ← Parent class (LitData + Polars backend) -│ │ └── configs/ -│ │ └── ptbxl.yaml ← ★ YAML schema -│ ├── tasks/ -│ │ ├── __init__.py ← imports PTBXLMultilabelClassification -│ │ ├── ptbxl_multilabel_classification.py ← ★ Task implementation -│ │ └── base_task.py ← Parent class -│ └── models/ -│ └── sparcnet.py ← Model used in ablation -├── docs/api/ -│ ├── datasets.rst ← ★ toctree entry added -│ ├── tasks.rst ← ★ toctree entry added -│ ├── datasets/ -│ │ └── pyhealth.datasets.PTBXLDataset.rst ← ★ Dataset doc -│ └── tasks/ -│ └── pyhealth.tasks.PTBXLMultilabelClassification.rst ← ★ Task doc -├── tests/core/ -│ └── test_ptbxl.py ← ★ Unit tests (18 cases) -└── examples/ - └── ptbxl_superdiagnostic_sparcnet.ipynb ← ★ Ablation notebook -``` - ---- - -## 3. PyHealth 5-Stage Pipeline - -Every PyHealth 2.0 project follows a strictly ordered 5-stage pipeline. The boxes in **bold** are where our code lives. - -```mermaid -flowchart LR - A["Stage 1\nDataset Process\npyhealth.datasets"] --> - B["Stage 2\nDefine Task\npyhealth.tasks"] --> - C["Stage 3\nModel Init\npyhealth.models"] --> - D["Stage 4\nTraining\npyhealth.trainer"] --> - E["Stage 5\nInference & Eval\npyhealth.metrics"] - - style A fill:#4a90d9,color:#fff - style B fill:#27ae60,color:#fff - style C fill:#8e44ad,color:#fff - style D fill:#e67e22,color:#fff - style E fill:#c0392b,color:#fff -``` - -| Stage | API | Our contribution | -|---|---|---| -| 1 Dataset Process | `pyhealth.datasets.PTBXLDataset` | Parses WFDB `.hea`/`.mat` files | -| 2 Define Task | `pyhealth.tasks.PTBXLMultilabelClassification` | 2×2 ablation (label_type × rate) | -| 3 Model Init | `pyhealth.models.SparcNet` | Existing model, no change needed | -| 4 Training | `pyhealth.trainer.Trainer` | Existing trainer, no change needed | -| 5 Eval | `pyhealth.metrics.multilabel_metrics_fn` | macro ROC-AUC + macro F1 | - ---- - -## 4. Stage 1 — Dataset Implementation - -### 4.1 YAML Config (`pyhealth/datasets/configs/ptbxl.yaml`) - -The YAML file tells `BaseDataset` how to interpret the metadata CSV we generate: - -```yaml -version: "1.0.0" - -tables: - ptbxl: - file_path: "ptbxl-pyhealth.csv" # CSV produced by prepare_metadata() - patient_id: "patient_id" # column that identifies the patient - timestamp: null # no visit timestamp for ECG records - attributes: - - record_id # WFDB record stem, e.g. "HR00001" - - signal_file # absolute path to the .mat file - - age # integer years (parsed from # Age: header line) - - sex # "Male" or "Female" - - scp_codes # comma-separated SNOMED-CT code string, e.g. "426783006,251146004" -``` - -**Key design decisions:** -- `timestamp: null` — ECG recordings are single snapshots, not time-series visits. -- `signal_file` stores the **absolute** path so the task can load the file from any working directory. -- `scp_codes` is kept as a raw string; the task is responsible for parsing and mapping it. - ---- - -### 4.2 PTBXLDataset Class - -`PTBXLDataset` inherits from `BaseDataset` (PyHealth's Polars + LitData-backed dataset engine). - -``` -PTBXLDataset -│ -├── __init__(root, dataset_name, config_path, **kwargs) -│ Step 1: resolve config_path → configs/ptbxl.yaml -│ Step 2: call prepare_metadata() -│ Step 3: resolve effective_root (shared CSV vs cache CSV) -│ Step 4: super().__init__(root=effective_root, tables=["ptbxl"], ...) -│ -├── prepare_metadata() ← Scans .hea files, builds ptbxl-pyhealth.csv -│ -└── default_task (property) ← Returns PTBXLMultilabelClassification( - label_type="superdiagnostic", sampling_rate=100) -``` - ---- - -### 4.3 `prepare_metadata` Flow - -This is the most complex operation in the dataset class. It runs once on first use and is idempotent thereafter. - -```mermaid -flowchart TD - START([prepare_metadata called]) --> CHECK{CSV exists at\nroot/ or ~/.cache/?} - CHECK -- yes --> SKIP[Return early\n no-op] - CHECK -- no --> SCAN[Glob g*/ group dirs\nsorted alphabetically] - - SCAN --> FOR_GROUP[For each group_dir] - FOR_GROUP --> FOR_HEA[For each .hea file] - FOR_HEA --> MAT_CHECK{.mat file\nexists?} - MAT_CHECK -- no --> WARN_MAT[Log warning\nSkip record] - MAT_CHECK -- yes --> PARSE[Parse .hea header\nExtract Age / Sex / Dx] - PARSE --> APPEND[Append row to list\npatient_id, record_id,\nsignal_file, age, sex, scp_codes] - APPEND --> MORE_HEA{More .hea\nfiles?} - MORE_HEA -- yes --> FOR_HEA - MORE_HEA -- no --> MORE_GROUP{More group\ndirs?} - MORE_GROUP -- yes --> FOR_GROUP - MORE_GROUP -- no --> EMPTY{rows list\nempty?} - EMPTY -- yes --> ERROR[Raise RuntimeError\nNo .hea files found] - EMPTY -- no --> SORT["Sort by patient_id\npd.DataFrame → reset_index"] - SORT --> WRITE_TRY{Try writing\nroot/ptbxl-pyhealth.csv} - WRITE_TRY -- success --> DONE([Done]) - WRITE_TRY -- PermissionError/OSError --> FALLBACK[Write to\n~/.cache/pyhealth/ptbxl/\nptbxl-pyhealth.csv] - FALLBACK --> DONE - - style ERROR fill:#e74c3c,color:#fff - style DONE fill:#27ae60,color:#fff -``` - ---- - -### 4.4 Header Parsing - -Each `.hea` (WFDB header) file contains plain-text comment lines. The parser extracts three of them: - -``` -HR00001 12 500 5000 ← WFDB signal header (ignored except record ID from filename) -# Age: 56 ← parsed → age = 56 -# Sex: Female ← parsed → sex = "Female" -# Dx: 426783006,251146004 ← parsed → scp_codes = "426783006,251146004" -``` - -**Parsing logic (pseudocode):** -``` -for line in hea_file.splitlines(): - if line starts with "# Age:": - age = int(float(line.after(":"))) # float() handles "56.0" edge cases - if line starts with "# Sex:": - sex = line.after(":") - if line starts with "# Dx:": - scp_codes = line.after(":") # raw comma-separated string -``` - -**Resulting CSV rows (example):** - -| patient_id | record_id | signal_file | age | sex | scp_codes | -|---|---|---|---|---|---| -| HR00001 | HR00001 | /data/.../HR00001.mat | 56 | Female | 426783006,251146004 | -| HR00002 | HR00002 | /data/.../HR00002.mat | 42 | Male | 270492004 | - -> **Why `patient_id == record_id`?** -> The Challenge 2020 PTB-XL files do not embed an explicit patient ID in the header — each recording file is treated as an independent sample. Setting both columns to the record stem (`HR00001`) lets `BaseDataset` build a one-patient-per-recording data model without special casing. - ---- - -### 4.5 Dataset → BaseDataset Sequence - -```mermaid -sequenceDiagram - actor User - participant PTBXLDataset - participant prepare_metadata - participant BaseDataset - participant Polars - participant LitData - - User->>PTBXLDataset: PTBXLDataset(root="/data/.../ptb-xl/") - PTBXLDataset->>prepare_metadata: prepare_metadata() - prepare_metadata-->>PTBXLDataset: ptbxl-pyhealth.csv written (or already existed) - - PTBXLDataset->>BaseDataset: super().__init__(root, tables=["ptbxl"], config_path) - BaseDataset->>Polars: Read ptbxl-pyhealth.csv via YAML schema - Polars-->>BaseDataset: Polars DataFrame (one row per recording) - BaseDataset->>LitData: Serialize patient objects → global_event_df.parquet (cache) - LitData-->>BaseDataset: Cache ready - BaseDataset-->>PTBXLDataset: Initialisation complete - PTBXLDataset-->>User: dataset object ready - - User->>PTBXLDataset: dataset.stats() - PTBXLDataset-->>User: "21837 patients, 21837 visits, ..." - - User->>PTBXLDataset: patient = dataset.get_patient("HR00001") - PTBXLDataset-->>User: Patient(patient_id="HR00001", events=[...]) -``` - ---- - -## 5. Stage 2 — Task Implementation - -### 5.1 Label Space Definitions - -The task supports two label vocabularies. Both are defined as Python-level constants in `ptbxl_multilabel_classification.py`. - -#### Superdiagnostic (5 classes) - -```mermaid -graph LR - SNOMED["Many SNOMED-CT codes\nfrom # Dx: field"] - SNOMED -->|"426783006"| NORM["NORM\nNormal sinus rhythm"] - SNOMED -->|"57054005\n164865005\n413444003\n..."| MI["MI\nMyocardial Infarction"] - SNOMED -->|"164931005\n164934002\n59931005\n..."| STTC["STTC\nST/T-wave Change"] - SNOMED -->|"270492004\n164889003\n164909002\n..."| CD["CD\nConduction Disturbance"] - SNOMED -->|"55827005\n39732003\n251146004\n..."| HYP["HYP\nHypertrophy / Axis Deviation"] - - style NORM fill:#3498db,color:#fff - style MI fill:#e74c3c,color:#fff - style STTC fill:#f39c12,color:#fff - style CD fill:#9b59b6,color:#fff - style HYP fill:#1abc9c,color:#fff -``` - -The mapping `SNOMED_TO_SUPERDIAG` covers **53 SNOMED-CT codes** collapsed to 5 classes. - -#### Diagnostic (27 classes) - -The 27 SNOMED-CT codes officially scored in the PhysioNet / CinC Challenge 2020: - -| Code | Abbreviation | Condition | -|---|---|---| -| 270492004 | IAVB | First-degree AV block | -| 164889003 | AF | Atrial fibrillation | -| 164890007 | AFL | Atrial flutter | -| 6374002 | BBB | Bundle branch block | -| 426627000 | Brady | Bradycardia | -| 713427006 | CRBBB | Complete right BBB | -| 713426002 | CLBBB | Complete left BBB | -| 445118002 | LAnFB | Left anterior fascicular block | -| 39732003 | LAD | Left axis deviation | -| 164909002 | LBBB | Left bundle branch block | -| 251146004 | LQRSV | Low QRS voltage | -| 698252002 | NSIVCB | Non-specific IVCD | -| 10370003 | PR | Pacing rhythm | -| 164947007 | LPR | Prolonged PR interval | -| 164917005 | LQT | Prolonged QT interval | -| 47665007 | RAD | Right axis deviation | -| 427393009 | SA | Sinus arrhythmia | -| 426177001 | SB | Sinus bradycardia | -| 426783006 | NSR | Normal sinus rhythm | -| 427084000 | ST | Sinus tachycardia | -| 63593006 | SVPB | Supraventricular premature beats | -| 164934002 | STD | ST depression | -| 59931005 | TWA | T-wave abnormality | -| 164931005 | STE | ST elevation | -| 17338001 | VPB | Ventricular premature beats | -| 284470004 | PAC | Premature atrial contraction | -| 427172004 | PVC | Premature ventricular contraction | - ---- - -### 5.2 PTBXLMultilabelClassification Class - -``` -PTBXLMultilabelClassification(BaseTask) -│ -├── Class-level schema constants -│ task_name : str = "PTBXLMultilabelClassification" (overridden in __init__) -│ input_schema: dict = {"signal": "tensor"} → TensorProcessor -│ output_schema: dict = {"labels": "multilabel"} → MultiLabelProcessor -│ -├── __init__(sampling_rate=100, label_type="superdiagnostic") -│ Validates: sampling_rate ∈ {100, 500} -│ Validates: label_type ∈ {"superdiagnostic", "diagnostic"} -│ Sets unique task_name to avoid cache collisions: -│ "PTBXLSuperDiagnostic_100Hz" -│ "PTBXLSuperDiagnostic_500Hz" -│ "PTBXLDiagnostic27_100Hz" -│ "PTBXLDiagnostic27_500Hz" -│ -└── __call__(patient: Patient) → List[Dict] - Per-patient sample extraction (see next section) -``` - ---- - -### 5.3 `__call__` Flow per Patient - -`BaseDataset.set_task(task)` calls `task(patient)` for every patient. In PTB-XL each patient has exactly one event (one recording), so each call returns at most one sample. - -```mermaid -flowchart TD - START(["task(patient) called"]) --> GET_EVENTS["events = patient.get_events(event_type='ptbxl')"] - GET_EVENTS --> FOR_EVENT[For each event] - FOR_EVENT --> CHECK_FILE{signal_file\nattribute set?} - - CHECK_FILE -- no --> SKIP1[Skip → debug log] - CHECK_FILE -- yes --> LOAD["loadmat(signal_file)\n→ mat['val'] shape: 12×5000"] - LOAD --> LOAD_OK{loadmat\nsucceeded?} - LOAD_OK -- no --> SKIP2[Skip → warning log] - LOAD_OK -- yes --> SHAPE{signal.ndim==2\nand shape[0]==12?} - SHAPE -- no --> SKIP3[Skip → warning log] - SHAPE -- yes --> RESAMPLE{sampling_rate\n== 100?} - RESAMPLE -- yes --> DECIMATE["signal = signal[:, ::5]\nshape: 12×1000"] - RESAMPLE -- no --> KEEP["signal unchanged\nshape: 12×5000"] - - DECIMATE --> PARSE_CODES - KEEP --> PARSE_CODES - - PARSE_CODES["Parse scp_codes string\n'426783006,251146004' → ['426783006','251146004']"] - PARSE_CODES --> LABEL_TYPE{label_type?} - - LABEL_TYPE -- superdiagnostic --> MAP5["Map codes via SNOMED_TO_SUPERDIAG\nlabels = set of NORM/MI/STTC/CD/HYP"] - LABEL_TYPE -- diagnostic --> MAP27["Filter codes ∈ CHALLENGE_SNOMED_CLASSES\nlabels = matching SNOMED strings"] - - MAP5 --> EMPTY_LABELS{labels\nempty?} - MAP27 --> EMPTY_LABELS - EMPTY_LABELS -- yes --> SKIP4[Skip record] - EMPTY_LABELS -- no --> APPEND_SAMPLE["samples.append\n{'signal': ndarray, 'labels': List[str]}"] - - SKIP1 --> NEXT_EVENT{More events?} - SKIP2 --> NEXT_EVENT - SKIP3 --> NEXT_EVENT - SKIP4 --> NEXT_EVENT - APPEND_SAMPLE --> NEXT_EVENT - - NEXT_EVENT -- yes --> FOR_EVENT - NEXT_EVENT -- no --> RETURN(["return samples"]) - - style SKIP1 fill:#e0e0e0 - style SKIP2 fill:#e0e0e0 - style SKIP3 fill:#e0e0e0 - style SKIP4 fill:#e0e0e0 - style RETURN fill:#27ae60,color:#fff -``` - ---- - -### 5.4 Decimation: 500 Hz → 100 Hz - -The raw PTB-XL signals are recorded at **500 Hz** — 5,000 samples per 10-second lead. When `sampling_rate=100`, the task decimates by a factor of 5 using simple stride slicing: - -``` -Native signal: X ∈ ℝ^{12 × 5000} (500 Hz) - ↓ signal[:, ::5] -Decimated: X ∈ ℝ^{12 × 1000} (100 Hz) -``` - -This is **no-filter decimation** (take every 5th sample). It is fast and avoids a scipy dependency in the hot path, matching the practice in Strodthoff *et al.* (2021). Proper anti-aliasing (e.g., `scipy.signal.decimate`) could be used for production quality but is not required for this ablation study. - -``` -Time axis: [t₀, t₁, t₂, t₃, t₄, t₅, t₆, t₇, t₈, t₉, t₁₀, ...] - ↑ 5000 samples -Keep: [t₀, t₅, t₁₀, t₁₅, ...] - ↑ 1000 samples -``` - ---- - -## 6. Mathematical Framing - -### 6.1 Signal Representation - -Each ECG recording is a 2-D tensor with 12 leads and T time steps: - -$$X \in \mathbb{R}^{C \times T}, \quad C = 12, \quad T \in \{1000, 5000\}$$ - -The ground-truth annotation for that recording is a **multi-hot binary vector**: - -$$y \in \{0, 1\}^K, \quad K \in \{5, 27\}$$ - -where $y_k = 1$ if class $k$ is present in the recording and $y_k = 0$ otherwise. Multiple classes can be 1 simultaneously (hence "multi-label"). - ---- - -### 6.2 Forward Pass - -The SparcNet backbone $f_\theta$ maps the signal to a feature embedding, which a linear head then projects to $K$ logit scores: - -$$\hat{y} = \sigma\!\left(f_\theta(X)\,W^\top + b\right) \in [0,1]^K$$ - -where $\sigma(z) = 1/(1 + e^{-z})$ is the element-wise sigmoid, $W \in \mathbb{R}^{K \times d}$ is the output weight matrix ($d$ = embedding dimension), and $b \in \mathbb{R}^K$ is the bias vector. - -Each output $\hat{y}_k$ is the predicted **probability** that class $k$ is present. - ---- - -### 6.3 Loss Function - -Training uses the **element-wise Binary Cross-Entropy** loss (BCE), summed independently per class: - -$$\mathcal{L}_{\text{BCE}} = -\frac{1}{K}\sum_{k=1}^{K}\Big[y_k\log\hat{y}_k + (1 - y_k)\log(1 - \hat{y}_k)\Big]$$ - -BCE is appropriate for multi-label problems because each output neuron is an independent binary classifier. Unlike cross-entropy for multi-class, the $K$ outputs do **not** share a softmax normalisation — they are modelled as $K$ independent Bernoulli random variables. - -PyHealth's `BaseModel.get_loss_function()` automatically returns `F.binary_cross_entropy_with_logits` when `output_schema["labels"] = "multilabel"` — which is applied to raw logits (before sigmoid) for numerical stability. - ---- - -### 6.4 Evaluation Metrics - -#### Macro ROC-AUC - -For each class $k$, the **Receiver Operating Characteristic** (ROC) curve is traced by varying the threshold $t$ and plotting: - -$$\text{TPR}_k(t) = \frac{\text{TP}_k(t)}{\text{TP}_k(t) + \text{FN}_k(t)}, \quad \text{FPR}_k(t) = \frac{\text{FP}_k(t)}{\text{FP}_k(t) + \text{TN}_k(t)}$$ - -The AUC for class $k$ is the area under this curve: - -$$\text{AUC}_k = \int_0^1 \text{TPR}_k(t)\,d\,\text{FPR}_k(t)$$ - -Macro-averaging gives equal weight to all classes regardless of prevalence: - -$$\overline{\text{AUC}} = \frac{1}{K}\sum_{k=1}^{K}\text{AUC}_k$$ - -An AUC of 0.5 corresponds to random guessing; 1.0 is perfect. - -#### Macro F1 - -At a fixed threshold of 0.5, we convert $\hat{y}_k$ to binary predictions and compute per-class F1: - -$$F_{1,k} = \frac{2\,\text{TP}_k}{2\,\text{TP}_k + \text{FP}_k + \text{FN}_k}$$ - -$$\overline{F_1} = \frac{1}{K}\sum_{k=1}^{K}F_{1,k}$$ - -F1 is more sensitive to class imbalance than AUC and penalises both false positives and false negatives. - ---- - -## 7. Ablation Study Design - -The ablation varies **two independent axes** and holds all training hyper-parameters constant: - -``` -label_type × sampling_rate → 2 × 2 = 4 configurations -``` - -```mermaid -quadrantChart - title Ablation Grid: Label Granularity vs Temporal Resolution - x-axis "Coarse labels (5-class)" --> "Fine labels (27-class)" - y-axis "Low resolution (100 Hz)" --> "High resolution (500 Hz)" - quadrant-1 Hard + High-Res - quadrant-2 Baseline + High-Res - quadrant-3 Baseline (default) - quadrant-4 Hard + Low-Res - Config A: [0.1, 0.1] - Config B: [0.1, 0.9] - Config C: [0.9, 0.1] - Config D: [0.9, 0.9] -``` - -| Config | `label_type` | `sampling_rate` | $K$ | $T$ | Expected AUC trend | -|---|---|---|---|---|---| -| **A** (baseline) | superdiagnostic | 100 Hz | 5 | 1 000 | Highest (easiest) | -| **B** | superdiagnostic | 500 Hz | 5 | 5 000 | ≥ A (more info) | -| **C** | diagnostic | 100 Hz | 27 | 1 000 | < A (harder task) | -| **D** | diagnostic | 500 Hz | 27 | 5 000 | ≤ B, ≥ C (trade-off) | - -**Hyper-parameters fixed across all configs** (from the paper's grid search): - -| Parameter | Value | -|---|---| -| Batch size | 64 | -| Learning rate | 0.001 (Adam) | -| Epochs | 5 (smoke test) / 20–30 (full repro) | -| Split | 70 / 10 / 20 % (train / val / test, by patient) | -| Monitor metric | macro ROC-AUC (validation) | -| Model | SparcNet (DenseNet-style 1-D CNN) | - -**Why SparcNet?** -SparcNet's dense-block architecture with successive max-pooling layers produces a receptive field that grows proportionally with $T$, making it naturally suited to comparing signals of different lengths (1 000 vs 5 000). - ---- - -## 8. Module Registration (`__init__` imports) - -Both the dataset and task must be exported from their package's `__init__.py` so users can write `from pyhealth.datasets import PTBXLDataset` without knowing the internal module path. - -### `pyhealth/datasets/__init__.py` (existing line 83) - -```python -from .ptbxl import PTBXLDataset -``` - -### `pyhealth/tasks/__init__.py` (existing line 69) - -```python -from .ptbxl_multilabel_classification import PTBXLMultilabelClassification -``` - -These lines were **already present** in the repository (written as part of the initial implementation). - ---- - -## 9. Documentation (RST + toctree) - -PyHealth uses [Sphinx](https://www.sphinx-doc.org/) with `autoclass` directives to auto-generate API reference from docstrings. - -### Dataset RST (`docs/api/datasets/pyhealth.datasets.PTBXLDataset.rst`) - -```rst -pyhealth.datasets.PTBXLDataset -============================== - -PTB-XL is a publically available electrocardiography dataset... - -.. autoclass:: pyhealth.datasets.PTBXLDataset - :members: - :undoc-members: - :show-inheritance: -``` - -This file **already existed** at line 241 of `datasets.rst`: -```rst -datasets/pyhealth.datasets.PTBXLDataset -``` - -### Task RST (`docs/api/tasks/pyhealth.tasks.PTBXLMultilabelClassification.rst`) — **newly created** - -```rst -pyhealth.tasks.PTBXLMultilabelClassification -============================================ - -PTB-XL is a large publicly available 12-lead ECG dataset... -Two label spaces are supported via the ``label_type`` argument... - -.. autoclass:: pyhealth.tasks.PTBXLMultilabelClassification - :members: - :undoc-members: - :show-inheritance: -``` - -### `docs/api/tasks.rst` toctree — **line added** - -```rst - PTB-XL Multi-Label ECG Classification -``` - ---- - -## 10. Test Suite - -### 10.1 Test Architecture - -```mermaid -classDiagram - class TestPTBXLDataset { - +_make_ds(root) PTBXLDataset - +test_prepare_metadata_basic() - +test_prepare_metadata_multiple_groups() - +test_prepare_metadata_skips_missing_mat() - +test_prepare_metadata_idempotent() - +test_prepare_metadata_no_records_raises() - +test_default_task_returns_superdiagnostic_instance() - } - - class TestPTBXLMultilabelClassification { - +_make_mat_file(tmp_dir, name, signal) str - +_make_patient(signal_file, scp_codes) _FakePatient - +test_invalid_sampling_rate_raises() - +test_invalid_label_type_raises() - +test_task_names_are_unique() - +test_superdiagnostic_100hz_signal_shape() - +test_superdiagnostic_500hz_signal_shape() - +test_signal_dtype_is_float32() - +test_superdiagnostic_normal_label() - +test_superdiagnostic_multilabel() - +test_superdiagnostic_no_known_codes_skipped() - +test_diagnostic_known_challenge_code() - +test_diagnostic_non_challenge_code_skipped() - +test_diagnostic_multiple_valid_codes() - +test_missing_signal_file_returns_empty() - +test_nonexistent_signal_file_returns_empty() - +test_empty_patient_no_events() - +test_wrong_signal_shape_skipped() - +test_superdiag_classes_count() - +test_challenge_classes_count() - +test_snomed_to_superdiag_values() - } - - class _FakeEvent { - +signal_file: str - +scp_codes: str - +age: int - +sex: str - } - - class _FakePatient { - +patient_id: str - +get_events(event_type) List - } - - TestPTBXLMultilabelClassification --> _FakePatient - _FakePatient --> _FakeEvent -``` - -**Total: 18 + 3 (constant checks) = ~21 assertions** across the two test classes. - -**Design principle:** All tests are **fully offline** — no network, no real ECG data. Fake filesystems use Python's `tempfile.TemporaryDirectory` and `scipy.io.savemat` to write real-format `.mat` files into memory. - ---- - -### 10.2 Dataset Tests - -```mermaid -sequenceDiagram - participant Test - participant tempfile - participant PTBXLDataset - participant Filesystem - - Test->>tempfile: TemporaryDirectory() - tempfile-->>Test: tmp path - - Test->>Filesystem: mkdir g1/ - Test->>Filesystem: write HR00001.hea (with Age, Sex, Dx) - Test->>Filesystem: write HR00001.mat (zero-byte placeholder) - - Test->>PTBXLDataset: PTBXLDataset.__new__(PTBXLDataset) - Note over Test,PTBXLDataset: Bypass BaseDataset.__init__ - Test->>PTBXLDataset: ds.root = tmp_path - Test->>PTBXLDataset: ds.prepare_metadata() - PTBXLDataset->>Filesystem: Scan g*/*.hea files - PTBXLDataset->>Filesystem: Write ptbxl-pyhealth.csv - PTBXLDataset-->>Test: Done - - Test->>Filesystem: pd.read_csv("ptbxl-pyhealth.csv") - Filesystem-->>Test: DataFrame - Test->>Test: assert len(df) == expected - Test->>Test: assert df columns present - Test->>Test: assert age / sex / scp_codes values -``` - -**Test cases for `TestPTBXLDataset`:** - -| Test | What it verifies | -|---|---| -| `test_prepare_metadata_basic` | CSV is created with correct schema + values for a 2-record dataset | -| `test_prepare_metadata_multiple_groups` | Records across g1, g2, g3 all appear | -| `test_prepare_metadata_skips_missing_mat` | Records where `.mat` is absent are silently skipped | -| `test_prepare_metadata_idempotent` | Calling twice neither crashes nor duplicates rows | -| `test_prepare_metadata_no_records_raises` | Empty group dir → `RuntimeError` | -| `test_default_task_returns_superdiagnostic_instance` | `default_task` property returns the right task type | - ---- - -### 10.3 Task Tests - -```mermaid -sequenceDiagram - participant Test - participant scipy_savemat - participant _FakePatient - participant PTBXLMultilabelClassification - - Test->>scipy_savemat: savemat(path, {"val": np.zeros((12,5000), float32)}) - scipy_savemat-->>Test: .mat file written to temp dir - - Test->>_FakePatient: _FakePatient("p001", [_FakeEvent(signal_file, scp_codes)]) - Note over _FakePatient: Simulates pyhealth.data.Patient without BaseDataset - - Test->>PTBXLMultilabelClassification: task = PTBXLMultilabelClassification(label_type, sampling_rate) - Test->>PTBXLMultilabelClassification: samples = task(fake_patient) - - PTBXLMultilabelClassification->>scipy_savemat: loadmat(signal_file) → mat["val"] - scipy_savemat-->>PTBXLMultilabelClassification: array shape (12, 5000) - Note over PTBXLMultilabelClassification: Decimate if sampling_rate==100 - Note over PTBXLMultilabelClassification: Parse scp_codes → map labels - - PTBXLMultilabelClassification-->>Test: [{"signal": ndarray, "labels": [...]}] - - Test->>Test: assert sample["signal"].shape == (12, expected_T) - Test->>Test: assert "NORM" in sample["labels"] - Test->>Test: assert sample["signal"].dtype == float32 -``` - -**Test cases for `TestPTBXLMultilabelClassification`:** - -| Test | What it verifies | -|---|---| -| `test_invalid_sampling_rate_raises` | `sampling_rate=250` raises `ValueError` | -| `test_invalid_label_type_raises` | `label_type="morphological"` raises `ValueError` | -| `test_task_names_are_unique` | All 4 configs produce distinct `task_name` strings | -| `test_superdiagnostic_100hz_signal_shape` | Output shape is `(12, 1000)` at 100 Hz | -| `test_superdiagnostic_500hz_signal_shape` | Output shape is `(12, 5000)` at 500 Hz | -| `test_signal_dtype_is_float32` | Signal is cast to `float32` even if input was `float64` | -| `test_superdiagnostic_normal_label` | Code `426783006` → label `"NORM"` | -| `test_superdiagnostic_multilabel` | Codes `164889003,251146004` → labels `{"CD", "HYP"}` | -| `test_superdiagnostic_no_known_codes_skipped` | Unknown code → empty sample list | -| `test_diagnostic_known_challenge_code` | Challenge code `270492004` → label `"270492004"` | -| `test_diagnostic_non_challenge_code_skipped` | Non-challenge code → empty sample list | -| `test_diagnostic_multiple_valid_codes` | Two challenge codes → both appear in labels | -| `test_missing_signal_file_returns_empty` | `signal_file=""` → `[]` | -| `test_nonexistent_signal_file_returns_empty` | Bad path → `[]` (exception caught) | -| `test_empty_patient_no_events` | Patient with 0 events → `[]` | -| `test_wrong_signal_shape_skipped` | `(1, 5000)` shape → skipped | -| `test_superdiag_classes_count` | `SUPERDIAG_CLASSES` has exactly 5 members | -| `test_challenge_classes_count` | `CHALLENGE_SNOMED_CLASSES` has exactly 27 members | -| `test_snomed_to_superdiag_values` | All dict values are in `{"NORM","MI","STTC","CD","HYP"}` | - ---- - -## 11. Example Notebook — Ablation Study - -**File:** `examples/ptbxl_superdiagnostic_sparcnet.ipynb` - -The notebook runs the full PyHealth pipeline for all 4 ablation configs and produces a comparative bar chart. - -### 11.1 End-to-End Pipeline Sequence - -```mermaid -sequenceDiagram - actor User - participant Notebook - participant PTBXLDataset - participant SampleDataset - participant SparcNet - participant Trainer - participant Metrics - - User->>Notebook: Set PTBXL_ROOT, BATCH_SIZE, LR, EPOCHS - - Notebook->>PTBXLDataset: PTBXLDataset(root=PTBXL_ROOT, dev=DEV_MODE) - PTBXLDataset-->>Notebook: base_dataset (21 837 recordings) - - loop For each of 4 ablation configs (A, B, C, D) - Notebook->>Notebook: task = PTBXLMultilabelClassification(label_type, sampling_rate) - Notebook->>PTBXLDataset: sample_ds = base_dataset.set_task(task) - Note over PTBXLDataset: For each patient: task(patient) → samples - PTBXLDataset-->>Notebook: SampleDataset (LitData-backed, indexable) - - Notebook->>SampleDataset: split_by_patient(sample_ds, [0.7, 0.1, 0.2]) - SampleDataset-->>Notebook: train_ds, val_ds, test_ds - - Notebook->>SparcNet: SparcNet(dataset=sample_ds) - Note over SparcNet: Reads input shape from sample_ds[0]["signal"] - SparcNet-->>Notebook: model - - Notebook->>Trainer: Trainer(model, device=DEVICE, metrics=[...]) - Notebook->>Trainer: trainer.train(train_loader, val_loader, epochs=EPOCHS, monitor="roc_auc_macro") - Note over Trainer: Each epoch: forward → BCE loss → Adam step → val eval - Trainer-->>Notebook: Best model checkpoint saved - - Notebook->>Trainer: trainer.evaluate(test_loader) - Trainer->>Metrics: multilabel_metrics_fn(y_true, y_prob, metrics=[...]) - Metrics-->>Trainer: {"roc_auc_macro": ..., "f1_macro": ...} - Trainer-->>Notebook: test_metrics dict - - Notebook->>Notebook: Append to results list - end - - Notebook->>Notebook: pd.DataFrame(results).display() - Notebook->>Notebook: matplotlib bar chart → ptbxl_ablation_results.png -``` - -### Key code pattern repeated for each config - -```python -# 1. Task definition -task = PTBXLMultilabelClassification(label_type="superdiagnostic", sampling_rate=100) - -# 2. Apply to dataset → SampleDataset -sample_ds = base_dataset.set_task(task) - -# 3. Split by patient (no data leakage) -train_ds, val_ds, test_ds = split_by_patient(sample_ds, [0.7, 0.1, 0.2]) - -# 4. Model from dataset schema -model = SparcNet(dataset=sample_ds) # auto-infers C=12, T=1000 - -# 5. Train -trainer = Trainer(model=model, device=DEVICE) -trainer.train(train_loader, val_loader, epochs=5, monitor="roc_auc_macro") - -# 6. Evaluate -metrics = trainer.evaluate(test_loader) -# → {"roc_auc_macro": 0.92, "f1_macro": 0.74, ...} -``` - ---- - -## 12. Data Layout - -``` -classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/ -└── training/ - └── ptb-xl/ ← pass this as root=... - ├── g1/ - │ ├── HR00001.hea ← WFDB header (ASCII, ~10 lines) - │ ├── HR00001.mat ← MATLAB signal matrix, 12×5000 float16 - │ ├── HR00002.hea - │ ├── HR00002.mat - │ └── ... ← ~1000 pairs per group - ├── g2/ - │ └── HR01001.hea / .mat - ├── ... - └── g22/ ← 22 groups total -``` - -After `prepare_metadata()` runs: - -``` -training/ptb-xl/ -└── ptbxl-pyhealth.csv ← Auto-generated index (21 837 rows) - columns: patient_id, record_id, signal_file, age, sex, scp_codes -``` - -After `set_task()` runs (first time): - -``` -~/.cache/pyhealth/ptbxl/ ← or custom cache_dir= -└── PTBXLSuperDiagnostic_100Hz/ ← one folder per task_name - ├── global_event_df.parquet - └── *.ld ← LitData binary shards -``` - ---- - -## 13. Dependency Graph - -```mermaid -graph TD - subgraph External["External Data"] - HEA[".hea WFDB headers"] - MAT[".mat signal matrices\n12 × 5000 float16"] - end - - subgraph Dataset["Dataset Layer (Stage 1)"] - YAML["ptbxl.yaml\nTable schema"] - META["prepare_metadata()\n→ ptbxl-pyhealth.csv"] - PTBXLDS["PTBXLDataset\n(BaseDataset)"] - end - - subgraph Task["Task Layer (Stage 2)"] - MAP5["SNOMED_TO_SUPERDIAG\n53 codes → 5 classes"] - MAP27["CHALLENGE_SNOMED_CLASSES\n27 codes"] - TASK["PTBXLMultilabelClassification\n(BaseTask)"] - end - - subgraph SampleDS["SampleDataset (set_task output)"] - SAMP["SampleDataset\n{'signal': tensor, 'labels': multi-hot}"] - end - - subgraph Model["Model Layer (Stage 3)"] - SPARCNET["SparcNet\n1-D DenseNet CNN"] - end - - subgraph Eval["Evaluation (Stage 5)"] - BCE["BCE Loss\n(training)"] - AUC["macro ROC-AUC\n(evaluation)"] - F1["macro F1\n(evaluation)"] - end - - HEA --> META - MAT --> META - YAML --> PTBXLDS - META --> PTBXLDS - - PTBXLDS -->|set_task| TASK - MAP5 --> TASK - MAP27 --> TASK - TASK --> SAMP - - SAMP --> SPARCNET - SPARCNET --> BCE - SPARCNET --> AUC - SPARCNET --> F1 - - style External fill:#ffeeba - style Dataset fill:#d4edda - style Task fill:#cce5ff - style SampleDS fill:#f8d7da - style Model fill:#e2d9f3 - style Eval fill:#fff3cd -``` - ---- - -## 14. References - -1. **Wagner, P. et al.** (2020). PTB-XL, a large publicly available electrocardiography dataset. *Scientific Data* 7, 154. https://doi.org/10.1038/s41597-020-0495-6 - -2. **Reyna, M.A. et al.** (2020). Will Two Do? Varying Dimensions in Electrocardiography: The PhysioNet/Computing in Cardiology Challenge 2020. *CinC 2020*. - -3. **Strodthoff, N. et al.** (2021). Deep Learning for ECG Analysis: Benchmarks and Insights from PTB-XL. *IEEE Journal of Biomedical and Health Informatics* 25(5), 1519–1528. - -4. **Jing, J. et al.** (2023). Development of Expert-Level Classification of Seizures and Rhythmic and Periodic Patterns During EEG Interpretation. *Neurology* 100, e1750–e1762. *(SparcNet paper)* - -5. **Zhao, M. et al.** (2024). PyHealth: A Deep Learning Toolkit for Healthcare Predictive Modeling. *arXiv:2401.06284*. - ---- - -*Document generated: April 8, 2026 | CS-598 DLH Project Team* diff --git a/cs598_project/ptbxl_pyhealth_pipeline.ipynb b/cs598_project/ptbxl_pyhealth_pipeline.ipynb deleted file mode 100644 index c2a71e55d..000000000 --- a/cs598_project/ptbxl_pyhealth_pipeline.ipynb +++ /dev/null @@ -1,7867 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7bb07c10", - "metadata": {}, - "source": [ - "# PTB-XL ECG Deep Learning Pipeline\n", - "## A Step-by-Step Explanation with Python Code and Flow Diagrams\n", - "\n", - "This notebook explains the full pipeline from raw ECG files on disk to a published, reproducible benchmark \u2014 the exact pipeline your CS-598 project proposes as a PyHealth contribution.\n", - "\n", - "```\n", - "Raw PTB-XL / CinC 2020 files on disk\n", - " \u2193 PTBXLDataset.process_EEG_data()\n", - "Structured patients dictionary (21,837 recordings, 1 ECG per entry)\n", - " \u2193 dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "SampleDataset (21,666 samples \u2014 full 10s ECG @ 100 Hz, multi-hot labels)\n", - " \u2193 split_by_patient([0.8, 0.1, 0.1], seed=42)\n", - "Train / Val / Test splits (no patient leakage)\n", - " \u2193 PyHealth Trainer + your model\n", - "Trained DNN (SparcNet, BiLSTMECG, ...)\n", - " \u2193 trainer.evaluate()\n", - "ROC-AUC macro + F1 macro scores \u2190 reproducible benchmark\n", - " \u2193\n", - "Published as a Colab notebook anyone can run\n", - "```\n", - "\n", - "Each section below: (1) explains what is happening conceptually, (2) shows the relevant Python code, and (3) renders a flow diagram for that stage." - ] - }, - { - "cell_type": "markdown", - "id": "3e5df7df", - "metadata": {}, - "source": [ - "---\n", - "## Section 1 \u2014 Install and Import Dependencies" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "89ecd1c1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " All imports successful\n", - " PyTorch : 2.8.0\n", - " Device : mps\n", - " PyHealth: 1.1.6\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/pyhealth/trainer.py:12: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from tqdm.autonotebook import trange\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Standard library & scientific stack \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "import ast\n", - "import os\n", - "import pickle\n", - "import sys\n", - "import warnings\n", - "from collections import defaultdict\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.patches as mpatches\n", - "import matplotlib.gridspec as gridspec\n", - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from sklearn.metrics import roc_auc_score, f1_score\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# PyHealth \u2014 the medical-AI framework used throughout this notebook.\n", - "#\n", - "# Install once with: pip install pyhealth\n", - "#\n", - "# PyHealth components used:\n", - "# \u2022 BaseSignalDataset \u2014 abstract base class for signal (ECG/EEG) datasets\n", - "# \u2022 SampleSignalDataset \u2014 wraps List[Dict] of task samples, handles epoch_path\n", - "# \u2022 split_by_patient \u2014 patient-level train/val/test split (no leakage)\n", - "# \u2022 get_dataloader \u2014 converts a SampleSignalDataset subset into a PyTorch DataLoader\n", - "# \u2022 SparcNet \u2014 DenseNet-based 1D signal classification model\n", - "# \u2022 BaseModel \u2014 abstract base for building custom PyHealth-compatible models\n", - "# \u2022 Trainer \u2014 training loop with early stopping + evaluation\n", - "# \u2022 multilabel_metrics_fn \u2014 computes roc_auc_macro, f1_macro, etc.\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "from pyhealth.datasets import (\n", - " BaseSignalDataset,\n", - " SampleSignalDataset,\n", - " get_dataloader,\n", - " split_by_patient,\n", - ")\n", - "from pyhealth.models import BaseModel, SparcNet\n", - "from pyhealth.trainer import Trainer\n", - "from pyhealth.metrics import multilabel_metrics_fn\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning, module=\"dask\")\n", - "\n", - "print(\" All imports successful\")\n", - "print(f\" PyTorch : {torch.__version__}\")\n", - "print(f\" Device : {'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'}\")\n", - "\n", - "try:\n", - " import pyhealth\n", - " print(f\" PyHealth: {pyhealth.__version__}\")\n", - "except Exception:\n", - " print(\" PyHealth: (version not exposed)\")\n", - "\n", - "DEVICE = \"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\"\n" - ] - }, - { - "cell_type": "markdown", - "id": "ab11ed5f", - "metadata": {}, - "source": [ - "---\n", - "## Section 2 \u2014 Full Pipeline Flow Diagram\n", - "\n", - "Before diving in, look at the entire pipeline end-to-end. \n", - "Each box below corresponds to one section of this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bdcff606", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 128190 (\\N{FLOPPY DISK}) missing from font(s) DejaVu Sans.\n", - " plt.tight_layout()\n", - "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 127959 (\\N{BUILDING CONSTRUCTION}) missing from font(s) DejaVu Sans.\n", - " plt.tight_layout()\n", - "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 127991 (\\N{LABEL}) missing from font(s) DejaVu Sans.\n", - " plt.tight_layout()\n", - "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 129504 (\\N{BRAIN}) missing from font(s) DejaVu Sans.\n", - " plt.tight_layout()\n", - "/var/folders/80/l6974fzd6jv2bwljchsl6r040000gn/T/ipykernel_1210/3496406396.py:54: UserWarning: Glyph 128202 (\\N{BAR CHART}) missing from font(s) DejaVu Sans.\n", - " plt.tight_layout()\n", - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 128190 (\\N{FLOPPY DISK}) missing from font(s) DejaVu Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 127959 (\\N{BUILDING CONSTRUCTION}) missing from font(s) DejaVu Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 127991 (\\N{LABEL}) missing from font(s) DejaVu Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 129504 (\\N{BRAIN}) missing from font(s) DejaVu Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/.venv/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 128202 (\\N{BAR CHART}) missing from font(s) DejaVu Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def draw_pipeline_overview():\n", - " \"\"\"Draw a top-level pipeline overview showing all 8 stages.\"\"\"\n", - " fig, ax = plt.subplots(figsize=(10, 16))\n", - " ax.set_xlim(0, 10)\n", - " ax.set_ylim(0, 16)\n", - " ax.axis(\"off\")\n", - " fig.patch.set_facecolor(\"#0d1117\")\n", - "\n", - " # \u2500\u2500 Stage definitions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " stages = [\n", - " # (y_center, box_color, text_color, icon, title, subtitle, section)\n", - " (14.5, \"#1e3a5f\", \"white\", \"\ud83d\udcbe\", \"Raw PTB-XL Files on Disk\",\n", - " \"ptbxl_database.csv + 21,837 WFDB signal pairs\\n(.dat / .hea, 500 Hz, 10 s, 12 leads)\", \"\u00a73\"),\n", - " (11.7, \"#1a4731\", \"white\", \"\ud83c\udfd7\ufe0f\", \"PTBXLDataset.process_EEG_data()\",\n", - " \"Groups all ECG records by patient_id\\n\u2192 patients dict: {pid: [record, ...]}\", \"\u00a74\u20135\"),\n", - " (8.9, \"#4a2f1a\", \"white\", \"\ud83c\udff7\ufe0f\", \"dataset.set_task(ptbxl_superdiagnostic_fn)\",\n", - " \"Slides 2.5-s windows over each signal\\nMaps scp_codes \u2192 5-class multi-hot label\\nSaves each window as .pkl \u2192 SampleDataset\", \"\u00a76\u20137\"),\n", - " (6.1, \"#3b1f4a\", \"white\", \"\u2702\ufe0f\", \"split_by_patient(ratios=[0.8, 0.1, 0.1])\",\n", - " \"Splits entire patients, not individual windows\\n\u2192 zero patient overlap across Train/Val/Test\", \"\u00a78\"),\n", - " (3.5, \"#4a1a1a\", \"white\", \"\ud83e\udde0\", \"PyHealth Trainer \u00d7 Your DNN Model\",\n", - " \"ResNet1d / BiLSTM / Transformer\\nBCEWithLogitsLoss (multi-label)\\nEarly stop on macro ROC-AUC\", \"\u00a79\u201310\"),\n", - " (1.0, \"#1a3a3a\", \"#00ffcc\",\"\ud83d\udcca\", \"trainer.evaluate() \u2192 Metrics\",\n", - " \"ROC-AUC macro + F1 macro\\nPer-class ROC curves\\nReproducible benchmark numbers\", \"\u00a711\u201312\"),\n", - " ]\n", - "\n", - " for (y, bg, fg, icon, title, subtitle, section) in stages:\n", - " # box\n", - " rect = plt.Rectangle((0.5, y - 1.0), 9.0, 1.8,\n", - " facecolor=bg, edgecolor=\"#ffffff44\",\n", - " linewidth=1.5, zorder=2)\n", - " ax.add_patch(rect)\n", - " # section badge\n", - " ax.text(9.2, y - 0.05, section, color=\"#aaaaaa\", fontsize=8,\n", - " ha=\"left\", va=\"center\", zorder=3)\n", - " # icon + title\n", - " ax.text(1.0, y + 0.45, icon + \" \" + title,\n", - " color=\"white\", fontsize=12, fontweight=\"bold\",\n", - " va=\"center\", ha=\"left\", zorder=3)\n", - " # subtitle\n", - " ax.text(1.0, y - 0.2, subtitle,\n", - " color=\"#bbbbbb\", fontsize=8.5, va=\"center\", ha=\"left\",\n", - " linespacing=1.6, zorder=3)\n", - "\n", - " # \u2500\u2500 Arrows between boxes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " arrow_y_pairs = [(13.5, 12.7), (10.7, 9.9), (7.9, 7.1), (5.1, 4.5), (2.5, 2.0)]\n", - " for (y1, y2) in arrow_y_pairs:\n", - " ax.annotate(\"\", xy=(5.0, y2), xytext=(5.0, y1),\n", - " arrowprops=dict(arrowstyle=\"-|>\", color=\"#00bfff\",\n", - " lw=2.0, mutation_scale=18),\n", - " zorder=4)\n", - "\n", - " ax.set_title(\"PTB-XL \u2192 PyHealth Pipeline \u2014 End to End\",\n", - " color=\"white\", fontsize=14, fontweight=\"bold\", pad=10)\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "draw_pipeline_overview()" - ] - }, - { - "cell_type": "markdown", - "id": "be9593e6", - "metadata": {}, - "source": [ - "---\n", - "## Section 3 \u2014 Raw PTB-XL Files on Disk\n", - "\n", - "### What is PTB-XL?\n", - "PTB-XL (Wagner et al., 2020, PhysioNet) is the **largest publicly available clinical 12-lead ECG dataset**:\n", - "- **21,837 recordings** from **18,885 unique patients** (paper figures; `ptbxl_database.csv` in this workspace has 21,799 / 18,869 due to minor version differences)\n", - "- Each recording: 10 seconds \u00d7 12 leads \u00d7 500 Hz = **5,000 time-points per lead** (60,000 total scalar values across all 12 leads)\n", - "- Labels: physician-annotated SCP codes (e.g. `NORM`, `MI`, `AFIB`) with confidence scores\n", - "\n", - "### Directory structure on disk (this workspace)\n", - "\n", - "This project uses the **PhysioNet/CinC 2020 Challenge (v1.0.2)** layout, which distributes PTB-XL records as flat MATLAB `.mat` files grouped into 22 sub-folders \u2014 **not** the standard `records100/` / `records500/` WFDB structure of PTB-XL v1.0.1:\n", - "\n", - "```\n", - "training/ptb-xl/ \u2190 PTBXL_CHALLENGE_ROOT\n", - "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", - "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", - "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 signal tensor (12 leads \u00d7 5000 samples @ 500 Hz)\n", - "\u2502 \u251c\u2500\u2500 HR00002.hea\n", - "\u2502 \u251c\u2500\u2500 HR00002.mat\n", - "\u2502 \u2514\u2500\u2500 ...\n", - "\u251c\u2500\u2500 g2/ ... g21/\n", - "\u2514\u2500\u2500 g22/ \u2190 group 22 (838 recordings)\n", - "\n", - "cs598_project/ \u2190 PROJECT_ROOT (Section B only)\n", - "\u251c\u2500\u2500 ptbxl_database.csv \u2190 PTB-XL 1.0.3 metadata (21,799 rows \u00d7 28 cols)\n", - "\u251c\u2500\u2500 scp_statements.csv \u2190 SCP code \u2192 diagnostic class lookup\n", - "\u2514\u2500\u2500 WFDB/\n", - " \u251c\u2500\u2500 HR00001.mat \u2190 same signals, flat layout (500 Hz)\n", - " \u2514\u2500\u2500 HR21837.mat\n", - "```\n", - "\n", - "> The standard PTB-XL v1.0.1 download has `records100/` (100 Hz) and `records500/` (500 Hz) WFDB `.dat`/`.hea` pairs. Those sub-folders are **not present** here \u2014 signals are loaded directly from `.mat` files.\n", - "\n", - "### Key columns in `ptbxl_database.csv` (PTB-XL 1.0.3, used in Section B)\n", - "\n", - "| Column | Meaning |\n", - "|---|---|\n", - "| `ecg_id` | Unique recording ID (1\u201321799) |\n", - "| `patient_id` | Which patient (1\u201318869) \u2014 multiple ECGs per patient possible |\n", - "| `filename_hr` | Relative path to 500 Hz WFDB file |\n", - "| `filename_lr` | Relative path to 100 Hz WFDB file |\n", - "| `scp_codes` | Dict string `{\"SCP_abbreviation\": confidence}` e.g. `\"{'NORM': 100.0}\"` |\n", - "| `strat_fold` | Cross-validation fold (1\u201310); folds 9\u201310 are human-validated |\n", - "| `age`, `sex` | Patient demographics |\n", - "\n", - "### Key columns in `ptbxl-pyhealth.csv` (CinC 2020 format, used in Sections A onward)\n", - "\n", - "| Column | Meaning |\n", - "|---|---|\n", - "| `patient_id` | Record stem \u2014 same as `record_id` (e.g. `HR00001`) |\n", - "| `record_id` | Record stem |\n", - "| `signal_file` | Absolute path to `.mat` file |\n", - "| `scp_codes` | SNOMED-CT numeric codes, comma-separated e.g. `\"426783006,251146004\"` |\n", - "| `sampling_rate` | Always 500 |\n", - "| `num_samples` | Always 5000 |\n", - "| `num_leads` | Always 12 |\n", - "| `group` | Parent group folder (`g1`\u2013`g22`) |" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8257b112", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ccc4653b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data format : ptbxl_wfdb\n", - "ptbxl_database.csv shape : (21799, 27)\n", - "Unique patients : 18,869\n", - "ECG recordings : 21,799\n", - "\n", - "First 3 rows (key columns):\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
patient_idagesexscp_codesstrat_fold
ecg_id
115709.056.01{'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}3
213243.019.00{'NORM': 80.0, 'SBRAD': 0.0}2
320372.037.01{'NORM': 100.0, 'SR': 0.0}5
\n", - "
" - ], - "text/plain": [ - " patient_id age sex scp_codes \\\n", - "ecg_id \n", - "1 15709.0 56.0 1 {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0} \n", - "2 13243.0 19.0 0 {'NORM': 80.0, 'SBRAD': 0.0} \n", - "3 20372.0 37.0 1 {'NORM': 100.0, 'SR': 0.0} \n", - "\n", - " strat_fold \n", - "ecg_id \n", - "1 3 \n", - "2 2 \n", - "3 5 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Signal file : HR00001.mat\n", - "Raw shape : (12, 5000) \u2192 (leads=12, samples=5000 @ 500 Hz)\n", - "Range (mV) : [-7.220, 3.450]\n", - "SCP codes : {'NORM': 100.0, 'LVOLT': 0.0, 'SR': 0.0}\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\u2705 Shape: (12, 5000) (12 leads \u00d7 5000 samples @ 500 Hz = 10s)\n" - ] - } - ], - "source": [ - "import ast\n", - "import scipy.io\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from pathlib import Path\n", - "\n", - "# \u2500\u2500 Data roots \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "_PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", - "_DB_CSV = _PROJECT_ROOT / \"ptbxl_database.csv\"\n", - "_WFDB_ROOT = _PROJECT_ROOT / \"WFDB\"\n", - "\n", - "_PTBXL_CINC = (\n", - " _PROJECT_ROOT.parent.parent /\n", - " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", - " / \"training\" / \"ptb-xl\"\n", - ")\n", - "\n", - "# \u2500\u2500 Auto-detect best available format \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "if _DB_CSV.exists() and _WFDB_ROOT.is_dir():\n", - " DATA_FORMAT = \"ptbxl_wfdb\" # ptbxl_database.csv + WFDB/ flat .mat files\n", - "elif (_PTBXL_CINC / \"ptbxl-pyhealth.csv\").exists():\n", - " DATA_FORMAT = \"cinc2020\"\n", - "else:\n", - " DATA_FORMAT = \"synthetic\"\n", - "\n", - "print(f\"Data format : {DATA_FORMAT}\")\n", - "\n", - "LEAD_NAMES = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def demo_raw_files(fmt):\n", - " if fmt == \"ptbxl_wfdb\":\n", - " _demo_ptbxl_wfdb(_DB_CSV, _WFDB_ROOT)\n", - " elif fmt == \"cinc2020\":\n", - " _demo_cinc2020(_PTBXL_CINC)\n", - " else:\n", - " print(\"No real data found. Generating SYNTHETIC demo...\\n\")\n", - " _show_synthetic_structure()\n", - "\n", - "\n", - "def _demo_ptbxl_wfdb(db_csv: Path, wfdb_root: Path):\n", - " \"\"\"\n", - " Show metadata from ptbxl_database.csv and load a real signal\n", - " from the WFDB/ flat .mat folder (500 Hz, channel-first).\n", - " \"\"\"\n", - " df = pd.read_csv(db_csv, index_col=\"ecg_id\")\n", - " df[\"scp_codes\"] = df[\"scp_codes\"].apply(ast.literal_eval)\n", - "\n", - " print(f\"ptbxl_database.csv shape : {df.shape}\")\n", - " print(f\"Unique patients : {df['patient_id'].nunique():,}\")\n", - " print(f\"ECG recordings : {len(df):,}\\n\")\n", - " print(\"First 3 rows (key columns):\")\n", - " display(df[[\"patient_id\",\"age\",\"sex\",\"scp_codes\",\"strat_fold\"]].head(3))\n", - "\n", - " # Load signal: ecg_id \u2192 WFDB/HR{ecg_id:05d}.mat\n", - " ecg_id = df.index[0] # = 1\n", - " mat_path = wfdb_root / f\"HR{ecg_id:05d}.mat\"\n", - " data = scipy.io.loadmat(str(mat_path))\n", - " signal = data[\"val\"].astype(float) # shape: (12, 5000) channel-first, 500 Hz\n", - " # Convert ADC \u2192 mV: gain = 200 ADC units/mV (from .hea file)\n", - " signal_mv = signal / 200.0\n", - "\n", - " print(f\"\\nSignal file : {mat_path.name}\")\n", - " print(f\"Raw shape : {signal.shape} \u2192 (leads=12, samples=5000 @ 500 Hz)\")\n", - " print(f\"Range (mV) : [{signal_mv.min():.3f}, {signal_mv.max():.3f}]\")\n", - " print(f\"SCP codes : {df.loc[ecg_id, 'scp_codes']}\")\n", - " _plot_raw_signal(signal_mv, fs=500,\n", - " title=f\"PTB-XL 1.0.3 (WFDB flat .mat) \u2014 ECG #{ecg_id} \"\n", - " f\"Age={int(df.loc[ecg_id,'age'])} \"\n", - " f\"{'F' if df.loc[ecg_id,'sex']==1 else 'M'}\")\n", - "\n", - "\n", - "def _demo_cinc2020(root: Path):\n", - " \"\"\"Show metadata and a real signal from CinC 2020 PTB-XL challenge data.\"\"\"\n", - " df = pd.read_csv(root / \"ptbxl-pyhealth.csv\")\n", - " print(f\"ptbxl-pyhealth.csv shape : {df.shape}\")\n", - " print(f\"ECG recordings : {len(df):,}\\n\")\n", - " display(df[[\"patient_id\",\"record_id\",\"age\",\"sex\",\"scp_codes\",\"group\"]].head(3))\n", - "\n", - " row = df.iloc[0]\n", - " mat = scipy.io.loadmat(str(root / row[\"signal_file\"]))\n", - " signal = mat[\"val\"].astype(float) / 200.0 # ADC \u2192 mV\n", - " fs = int(row[\"sampling_rate\"])\n", - " print(f\"\\nSignal loaded (CinC .mat) : {signal.shape}\")\n", - " _plot_raw_signal(signal, fs, title=\"CinC 2020 PTB-XL \u2014 Real 12-lead ECG (500 Hz)\")\n", - "\n", - "\n", - "def _show_synthetic_structure():\n", - " t = np.linspace(0, 10, 5000)\n", - " ecg_sim = np.zeros((12, 5000))\n", - " for lead in range(12):\n", - " ecg_sim[lead] = (0.03 * np.sin(2*np.pi*1.2*t)\n", - " + 1.2 * np.exp(-((t % (1/1.2) - 0.15)**2) / 0.0002)\n", - " - 0.1 * np.sin(2*np.pi*1.2*t + 0.5)\n", - " + 0.01 * np.random.randn(5000))\n", - " _plot_raw_signal(ecg_sim, 500, title=\"SYNTHETIC 12-lead ECG (demo)\")\n", - "\n", - "\n", - "def _plot_raw_signal(signal, fs, title=\"12-lead ECG\"):\n", - " \"\"\"signal shape: (12, n_samples).\"\"\"\n", - " n = signal.shape[1]\n", - " fig, axes = plt.subplots(6, 2, figsize=(14, 9), sharex=True)\n", - " fig.suptitle(f\"{title} \u2014 shape {signal.shape} ({fs} Hz \u00d7 {n//fs} s)\",\n", - " fontsize=11, fontweight=\"bold\")\n", - " axes_flat = axes.flatten()\n", - " for i in range(12):\n", - " axes_flat[i].plot(signal[i], linewidth=0.7, color=\"#1f77b4\")\n", - " axes_flat[i].set_ylabel(LEAD_NAMES[i], fontsize=8)\n", - " axes_flat[i].set_yticks([])\n", - " axes_flat[-1].set_xlabel(f\"Sample index (0\u2013{n} @ {fs} Hz)\")\n", - " axes_flat[-2].set_xlabel(f\"Sample index (0\u2013{n} @ {fs} Hz)\")\n", - " plt.tight_layout()\n", - " plt.show()\n", - " print(f\"\\n\u2705 Shape: {signal.shape} (12 leads \u00d7 {n} samples @ {fs} Hz = {n//fs}s)\")\n", - "\n", - "\n", - "demo_raw_files(DATA_FORMAT)\n" - ] - }, - { - "cell_type": "markdown", - "id": "07b055f0", - "metadata": {}, - "source": [ - "\n", - "`process_EEG_data()` is the **only abstract method** you must implement when subclassing `BaseSignalDataset`. \n", - "Its job is to convert the raw files into a single structured dictionary.\n", - "\n", - "### What happens inside it \u2014 sub-flow\n", - "\n", - "```\n", - "ptbxl-pyhealth.csv \u2190 built by prepare_metadata() in this notebook\n", - " \u2502\n", - " \u25bc\n", - "Read CSV \u2192 one row per recording (patient_id == record_id in CinC format)\n", - " \u2502\n", - " \u25bc\n", - "For each row: build a record dict with:\n", - " mat_path (absolute path to .mat signal file)\n", - " scp_codes (SNOMED-CT string, e.g. \"426783006,251146004\")\n", - " age, sex\n", - " \u2502\n", - " \u25bc\n", - "Group records by patient_id\n", - " \u2502\n", - " \u25bc\n", - "Return patients = {\n", - " \"HR00001\": [ {ecg_id:\"HR00001\", mat_path:\"/.../g1/HR00001.mat\",\n", - " scp_codes:\"251146004,426783006\", age:56, sex:\"Female\"} ],\n", - " \"HR00002\": [ {ecg_id:\"HR00002\", mat_path:\"/.../g1/HR00002.mat\",\n", - " scp_codes:\"426177001,426783006\", age:19, sex:\"Male\"} ],\n", - " ...\n", - " \"HR21837\": [ ... ]\n", - "}\n", - "```\n", - "\n", - "> **CinC 2020 format note:** In this dataset each recording is its own patient (`patient_id == record_id`), so no patient has multiple ECGs. There is **no `strat_fold`** column \u2014 train/val/test splits use random patient-level assignment instead (Section 8).\n", - "\n", - "**Key design principle:** `process_EEG_data()` does **NOT** load signal arrays \u2014 it only stores file paths. \n", - "Signal loading happens lazily, inside the task function (Section 6), so memory stays low." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f3bb5d93", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] \u2026\n", - " CinC root: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", - " CSV already present: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", - "\n", - " CSV ready: /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", - " Shape : (21837, 10) (21,837 records \u00d7 10 cols)\n", - " Columns : ['patient_id', 'record_id', 'signal_file', 'age', 'sex', 'scp_codes', 'sampling_rate', 'num_samples', 'num_leads', 'group']\n", - "\n", - "First 3 rows:\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
patient_idrecord_idsignal_fileagesexscp_codessampling_ratenum_samplesnum_leadsgroup
0HR00001HR00001g1/HR00001.mat56.0Female251146004,426783006500500012g1
1HR00002HR00002g1/HR00002.mat19.0Male426177001,426783006500500012g1
2HR00003HR00003g1/HR00003.mat37.0Female426783006500500012g1
\n", - "
" - ], - "text/plain": [ - " patient_id record_id signal_file age sex scp_codes \\\n", - "0 HR00001 HR00001 g1/HR00001.mat 56.0 Female 251146004,426783006 \n", - "1 HR00002 HR00002 g1/HR00002.mat 19.0 Male 426177001,426783006 \n", - "2 HR00003 HR00003 g1/HR00003.mat 37.0 Female 426783006 \n", - "\n", - " sampling_rate num_samples num_leads group \n", - "0 500 5000 12 g1 \n", - "1 500 5000 12 g1 \n", - "2 500 5000 12 g1 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "scp_codes example (row 0): '251146004,426783006'\n", - "\u2192 SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\n", - "\n", - "Step 4b: Initialising BaseSignalDataset adapter \u2026\n", - "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " PTBXLDataset (jtwells2 :: CinC 2020 format)\n", - " Source file : PyHealth/pyhealth/datasets/ptbxl.py\n", - " Records : 21,837 (22 group directories)\n", - " patient_id : equals record_id (CinC format)\n", - " scp_codes : SNOMED-CT numeric strings (binary, no confidence)\n", - " strat_fold : not available \u2192 random split\n", - "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n" - ] - } - ], - "source": [ - "\n", - "# \u2500\u2500 STEP 4: PTBXLDataset \u2014 wrapping jtwells2's pyhealth/datasets/ptbxl.py \u2500\u2500\u2500\u2500\n", - "#\n", - "# \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n", - "# \u2502 SOURCE FILE: PyHealth/pyhealth/datasets/ptbxl.py (jtwells2) \u2502\n", - "# \u2502 CLASS: PTBXLDataset(BaseDataset) \u2502\n", - "# \u2502 KEY METHOD: prepare_metadata() \u2502\n", - "# \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n", - "#\n", - "# jtwells2's PTBXLDataset.prepare_metadata() scans the CinC 2020 PTB-XL data:\n", - "#\n", - "# root/\n", - "# g1/ \u2192 HR00001.hea + HR00001.mat\n", - "# g2/ \u2192 HR01001.hea + HR01001.mat\n", - "# ...\n", - "# g22/\n", - "#\n", - "# Each .hea header contains comment lines:\n", - "# # Age: 56\n", - "# # Sex: Female\n", - "# # Dx: 426783006,251146004 \u2190 SNOMED-CT codes, comma-separated (binary)\n", - "#\n", - "# It produces ptbxl-pyhealth.csv with columns:\n", - "# patient_id | record_id | signal_file | age | sex | scp_codes | ...\n", - "#\n", - "# KEY DIFFERENCE from PTB-XL v1.0.3 native format:\n", - "# NEW: scp_codes = \"426783006,251146004\" (SNOMED-CT codes, binary)\n", - "#\n", - "# WHY BaseSignalDataset ADAPTER?\n", - "# jtwells2's PTBXLDataset extends BaseDataset, which is the local PyHealth's\n", - "# polars-based dataset (Python 3.10+ required). The installed pyhealth 1.1.6\n", - "# on Python 3.9 does not have this class. We replicate prepare_metadata()\n", - "# inline (same logic, line-for-line) and wrap in BaseSignalDataset so that\n", - "# the SparcNet + Trainer pipeline works without modification.\n", - "\n", - "CINC_PTBXL_ROOT = (\n", - " _PROJECT_ROOT.parent.parent /\n", - " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", - " / \"training\" / \"ptb-xl\"\n", - ")\n", - "\n", - "# \u2500\u2500 Step 4a: prepare_metadata() \u2014 exact replication of jtwells2's logic \u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Source: PyHealth/pyhealth/datasets/ptbxl.py :: PTBXLDataset.prepare_metadata()\n", - "def prepare_metadata(root: Path) -> Path:\n", - " \"\"\"\n", - " Scan g*/: .hea files \u2192 write ptbxl-pyhealth.csv.\n", - " Logic is a direct copy of jtwells2's PTBXLDataset.prepare_metadata().\n", - " Adds extra columns (sampling_rate, num_samples, num_leads, group) used\n", - " by the Challenge data but not strictly needed for our pipeline.\n", - " \"\"\"\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\"\n", - " shared_csv = root / \"ptbxl-pyhealth.csv\"\n", - " cache_csv = cache_dir / \"ptbxl-pyhealth.csv\"\n", - "\n", - " if shared_csv.exists():\n", - " print(f\" CSV already present: {shared_csv}\")\n", - " return shared_csv\n", - " if cache_csv.exists():\n", - " print(f\" Using cached CSV : {cache_csv}\")\n", - " return cache_csv\n", - "\n", - " rows = []\n", - " for gdir in sorted(root.glob(\"g*/\")):\n", - " if not gdir.is_dir():\n", - " continue\n", - " for hea in sorted(gdir.glob(\"*.hea\")):\n", - " mat = hea.with_suffix(\".mat\")\n", - " if not mat.exists():\n", - " continue\n", - " rid = hea.stem\n", - " age, sex, scp_codes = None, None, \"\"\n", - " for raw in hea.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines():\n", - " line = raw.strip()\n", - " if line.startswith(\"# Age:\"):\n", - " try: age = int(float(line.split(\":\", 1)[-1].strip()))\n", - " except: pass\n", - " elif line.startswith(\"# Sex:\"):\n", - " sex = line.split(\":\", 1)[-1].strip()\n", - " elif line.startswith(\"# Dx:\"):\n", - " scp_codes = line.split(\":\", 1)[-1].strip()\n", - " rows.append({\n", - " \"patient_id\": rid,\n", - " \"record_id\": rid,\n", - " \"signal_file\": str(mat.absolute()),\n", - " \"age\": age,\n", - " \"sex\": sex,\n", - " \"scp_codes\": scp_codes,\n", - " \"sampling_rate\": 500,\n", - " \"num_samples\": 5000,\n", - " \"num_leads\": 12,\n", - " \"group\": gdir.name,\n", - " })\n", - "\n", - " if not rows:\n", - " raise RuntimeError(\n", - " f\"No .hea files found under {root}. \"\n", - " \"Ensure CINC_PTBXL_ROOT points to training/ptb-xl/\"\n", - " )\n", - "\n", - " df = pd.DataFrame(rows).sort_values(\"patient_id\").reset_index(drop=True)\n", - " try:\n", - " df.to_csv(shared_csv, index=False)\n", - " return shared_csv\n", - " except (PermissionError, OSError):\n", - " cache_dir.mkdir(parents=True, exist_ok=True)\n", - " df.to_csv(cache_csv, index=False)\n", - " return cache_csv\n", - "\n", - "\n", - "print(\"Step 4a: Running prepare_metadata() [jtwells2 :: PTBXLDataset.prepare_metadata] \u2026\")\n", - "print(f\" CinC root: {CINC_PTBXL_ROOT}\")\n", - "csv_path = prepare_metadata(CINC_PTBXL_ROOT)\n", - "\n", - "df_meta = pd.read_csv(csv_path)\n", - "print(f\"\\n CSV ready: {csv_path}\")\n", - "print(f\" Shape : {df_meta.shape} ({df_meta.shape[0]:,} records \u00d7 {df_meta.shape[1]} cols)\")\n", - "print(f\" Columns : {df_meta.columns.tolist()}\")\n", - "print(f\"\\nFirst 3 rows:\")\n", - "display(df_meta.head(3))\n", - "print(f\"\\nscp_codes example (row 0): '{df_meta['scp_codes'].iloc[0]}'\")\n", - "print(\"\u2192 SNOMED-CT numeric codes, comma-separated, binary (no confidence %)\")\n", - "\n", - "\n", - "# \u2500\u2500 Step 4b: BaseSignalDataset adapter \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# jtwells2's PTBXLDataset(BaseDataset) uses the LOCAL PyHealth's polars-based\n", - "# BaseDataset. The installed pyhealth 1.1.6 has BaseSignalDataset instead.\n", - "# We bridge them with a thin adapter with the SAME process_EEG_data() contract.\n", - "#\n", - "# Schema stored per record (matches jtwells2's CSV columns):\n", - "# patient_id \u2014 record stem, e.g. \"HR00001\"\n", - "# ecg_id \u2014 same as patient_id (CinC format: each ECG is its own ID)\n", - "# mat_path \u2014 absolute path to .mat signal file\n", - "# scp_codes \u2014 \"426783006,251146004\" comma-separated SNOMED-CT string\n", - "# age, sex \u2014 from .hea header\n", - "\n", - "class PTBXLDataset(BaseSignalDataset):\n", - " \"\"\"\n", - " BaseSignalDataset adapter aligning jtwells2's CinC 2020 CSV format\n", - " with the installed pyhealth 1.1.6 Trainer / SparcNet pipeline.\n", - " \"\"\"\n", - " def __init__(self, csv_path: str, **kwargs):\n", - " self._csv_path = Path(csv_path)\n", - " super().__init__(\n", - " root=str(self._csv_path.parent),\n", - " dataset_name=\"ptbxl\",\n", - " **kwargs,\n", - " )\n", - "\n", - " def process_EEG_data(self) -> dict:\n", - " \"\"\"Parse ptbxl-pyhealth.csv \u2192 patients dict expected by BaseSignalDataset.\"\"\"\n", - " df = pd.read_csv(self._csv_path)\n", - " patients = defaultdict(list)\n", - " for _, row in df.iterrows():\n", - " pid = str(row[\"patient_id\"])\n", - " patients[pid].append({\n", - " \"patient_id\": pid,\n", - " \"ecg_id\": str(row[\"record_id\"]),\n", - " \"mat_path\": str(row[\"signal_file\"]),\n", - " # scp_codes is a SNOMED-CT comma-separated STRING (jtwells2 schema)\n", - " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", - " \"age\": row.get(\"age\"),\n", - " \"sex\": row.get(\"sex\"),\n", - " # No strat_fold in CinC format \u2014 splits will be random\n", - " })\n", - " return dict(patients)\n", - "\n", - " def stat(self):\n", - " total = sum(len(v) for v in self.patients.values())\n", - " n_groups = df_meta[\"group\"].nunique() if \"group\" in df_meta.columns else \"?\"\n", - " print(f\"{'\u2500'*58}\")\n", - " print(f\" PTBXLDataset (jtwells2 :: CinC 2020 format)\")\n", - " print(f\" Source file : PyHealth/pyhealth/datasets/ptbxl.py\")\n", - " print(f\" Records : {total:,} ({n_groups} group directories)\")\n", - " print(f\" patient_id : equals record_id (CinC format)\")\n", - " print(f\" scp_codes : SNOMED-CT numeric strings (binary, no confidence)\")\n", - " print(f\" strat_fold : not available \u2192 random split\")\n", - " print(f\"{'\u2500'*58}\")\n", - "\n", - "\n", - "print(\"\\nStep 4b: Initialising BaseSignalDataset adapter \u2026\")\n", - "dataset = PTBXLDataset(csv_path=str(csv_path))\n", - "dataset.stat()\n" - ] - }, - { - "cell_type": "markdown", - "id": "0282d6e5", - "metadata": {}, - "source": [ - "\n", - "After `process_EEG_data()`, we have `dataset.patients` \u2014 a plain Python `dict`.\n", - "\n", - "```python\n", - "dataset.patients = {\n", - " \"HR00001\": [ {\n", - " \"patient_id\": \"HR00001\",\n", - " \"ecg_id\": \"HR00001\",\n", - " \"mat_path\": \"/.../g1/HR00001.mat\",\n", - " \"scp_codes\": \"251146004,426783006\", # SNOMED-CT codes, comma-separated string\n", - " \"age\": 56,\n", - " \"sex\": \"Female\"\n", - " } ],\n", - " \"HR00002\": [ {\n", - " \"patient_id\": \"HR00002\",\n", - " \"ecg_id\": \"HR00002\",\n", - " \"mat_path\": \"/.../g1/HR00002.mat\",\n", - " \"scp_codes\": \"426177001,426783006\",\n", - " \"age\": 19,\n", - " \"sex\": \"Male\"\n", - " } ],\n", - " ...\n", - " \"HR21837\": [ ... ]\n", - "}\n", - "```\n", - "\n", - "> **Key differences from PTB-XL v1.0.3:**\n", - "> - `patient_id == record_id` (CinC 2020 assigns one ID per recording, not per person)\n", - "> - `scp_codes` is a **comma-separated SNOMED-CT numeric string** \u2014 not a dict with confidence scores\n", - "> - No `strat_fold` field \u2014 not available in CinC format\n", - "> - One record per patient (list always has length 1 in this dataset)\n", - "\n", - "**Why group by patient?** \n", - "`split_by_patient()` splits the `patients` dict first, then gathers all samples for each group. \n", - "Even though each patient here has exactly one ECG, splitting by `patient_id` rather than by sample index is the correct, leak-proof pattern \u2014 and it keeps the code identical to Section B which does have multiple ECGs per patient." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d2854a79", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dataset.patients : \n", - "Total entries : 21,837\n", - "\n", - "Patient/Record ID : HR00001\n", - "# records for this ID : 1\n", - "\n", - "Record field layout (jtwells2 schema):\n", - " patient_id : 'HR00001'\n", - " ecg_id : 'HR00001'\n", - " mat_path : 'g1/HR00001.mat'\n", - " scp_codes : '251146004,426783006'\n", - " age : 56.0\n", - " sex : 'Female'\n", - "\n", - "Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\n", - " (comma-separated binary codes \u2014 no confidence % field)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Unique SNOMED-CT codes in dataset : 50\n", - "Total code occurrences : 56,129\n", - "\n", - "Top 10 most common codes:\n", - " 426783006 \u00d7 18,092\n", - " 164865005 \u00d7 5,261\n", - " 39732003 \u00d7 5,146\n", - " 164951009 \u00d7 3,389\n", - " 164873001 \u00d7 2,359\n", - " 164934002 \u00d7 2,345\n", - " 164861001 \u00d7 2,175\n", - " 445118002 \u00d7 1,626\n", - " 164889003 \u00d7 1,514\n", - " 164884008 \u00d7 1,154\n", - "\n", - "\u2705 dataset.patients built. No signals loaded yet \u2014 only metadata + file paths.\n" - ] - } - ], - "source": [ - "\n", - "# \u2500\u2500 STEP 5: Inspect the patients dictionary (CinC 2020 format) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# In PTB-XL v1.0.3 native format: patients dict had 18,869 REAL patient IDs\n", - "# multiple ECGs per patient, strat_fold 1-10 for guaranteed splits\n", - "#\n", - "# In CinC 2020 format (jtwells2 :: PTBXLDataset):\n", - "# patient_id == record_id == \"HR00001\" (no true patient ID in .hea files)\n", - "# every ECG is its own \"patient\" \u2192 exactly 1 record per patient-ID\n", - "# no strat_fold \u2192 splits are random by recording\n", - "#\n", - "# This is a fundamental design decision in jtwells2's file: the Challenge 2020\n", - "# PTB-XL headers do NOT include a shared patient identifier, so the class\n", - "# treats each recording independently.\n", - "\n", - "print(f\"dataset.patients : {type(dataset.patients)}\")\n", - "print(f\"Total entries : {len(dataset.patients):,}\\n\")\n", - "\n", - "first_pid = list(dataset.patients.keys())[0]\n", - "first_recs = dataset.patients[first_pid]\n", - "\n", - "print(f\"Patient/Record ID : {first_pid}\")\n", - "print(f\"# records for this ID : {len(first_recs)}\")\n", - "print(\"\\nRecord field layout (jtwells2 schema):\")\n", - "for k, v in first_recs[0].items():\n", - " print(f\" {k:<14}: {repr(v)[:80]}\")\n", - "\n", - "print()\n", - "print(\"Note: 'scp_codes' is a SNOMED-CT string like '426783006,251146004'\")\n", - "print(\" (comma-separated binary codes \u2014 no confidence % field)\")\n", - "\n", - "# \u2500\u2500 Distribution plots \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "ecg_counts = [len(v) for v in dataset.patients.values()]\n", - "\n", - "# Count SNOMED codes per recording\n", - "code_counts = []\n", - "for recs in dataset.patients.values():\n", - " for r in recs:\n", - " codes = [c.strip() for c in str(r[\"scp_codes\"]).split(\",\") if c.strip()]\n", - " code_counts.append(len(codes))\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", - "\n", - "# Left: ECGs per patient-ID (should all be 1 in CinC format)\n", - "max_cnt = max(ecg_counts)\n", - "axes[0].hist(ecg_counts,\n", - " bins=range(1, max_cnt + 2),\n", - " color=\"#4a90d9\", edgecolor=\"white\", align=\"left\")\n", - "axes[0].set_title(\"ECG recordings per patient-ID\\n(CinC: patient_id == record_id)\",\n", - " fontsize=11, fontweight=\"bold\")\n", - "axes[0].set_xlabel(\"# recordings per ID\")\n", - "axes[0].set_ylabel(\"# patient-IDs\")\n", - "axes[0].set_xticks(range(1, max_cnt + 1))\n", - "\n", - "# Right: # SNOMED-CT codes per recording\n", - "from collections import Counter\n", - "cc = Counter(code_counts)\n", - "axes[1].bar(sorted(cc.keys()), [cc[k] for k in sorted(cc.keys())],\n", - " color=\"#e07b54\", edgecolor=\"white\")\n", - "axes[1].set_title(\"SNOMED-CT Dx codes per recording\\n(# codes in '# Dx:' header line)\",\n", - " fontsize=11, fontweight=\"bold\")\n", - "axes[1].set_xlabel(\"# SNOMED-CT codes\")\n", - "axes[1].set_ylabel(\"# recordings\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "# \u2500\u2500 Code vocabulary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "all_codes = []\n", - "for recs in dataset.patients.values():\n", - " for r in recs:\n", - " all_codes.extend([c.strip() for c in str(r[\"scp_codes\"]).split(\",\") if c.strip()])\n", - "\n", - "print(f\"\\nUnique SNOMED-CT codes in dataset : {len(set(all_codes))}\")\n", - "print(f\"Total code occurrences : {len(all_codes):,}\")\n", - "print(f\"\\nTop 10 most common codes:\")\n", - "top10 = Counter(all_codes).most_common(10)\n", - "for code, cnt in top10:\n", - " print(f\" {code} \u00d7 {cnt:,}\")\n", - "print(\"\\n\u2705 dataset.patients built. No signals loaded yet \u2014 only metadata + file paths.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "575df087", - "metadata": {}, - "source": [ - "\n", - "### What is a Task function?\n", - "\n", - "A **task function** is a plain Python function that:\n", - "\n", - "1. Receives **one patient's records** (the list from `dataset.patients[pid]`)\n", - "2. Loads the actual signal array from disk for each record via `scipy.io.loadmat()`\n", - "3. Decimates from native 500 Hz to 100 Hz: `signal[:, ::5]` \u2192 shape `(12, 1000)`\n", - "4. Converts SNOMED-CT `scp_codes` string into a **list of superdiagnostic class names**\n", - "5. Caches each sample as a `.pkl` file (loaded lazily per batch by `SampleSignalDataset`)\n", - "6. Returns a `List[Dict]` \u2014 **one dict per recording** = one training sample\n", - "\n", - "> **No sliding windows in this implementation.** The full 10-second recording is used as a single sample after decimation. Previous notebook versions used 2.5-second sliding windows at 500 Hz; the current version follows jtwells2's `PTBXLMultilabelClassification` which keeps the full waveform decimated to 100 Hz.\n", - "\n", - "### The 5 superdiagnostic classes\n", - "\n", - "PTB-XL's SCP codes are organized in a hierarchy. The **superdiagnostic** level has exactly 5 classes:\n", - "\n", - "| Index | Class | Meaning |\n", - "|---|---|---|\n", - "| 0 | `NORM` | Normal sinus rhythm |\n", - "| 1 | `MI` | Myocardial Infarction |\n", - "| 2 | `STTC` | ST/T-change (ischemia signs) |\n", - "| 3 | `CD` | Conduction Disturbance |\n", - "| 4 | `HYP` | Hypertrophy |\n", - "\n", - "A recording can have **multiple active classes simultaneously** \u2014 this is multi-label classification. \n", - "The label list `[\"NORM\", \"MI\"]` means \"Normal sinus rhythm and Myocardial Infarction are both present.\"\n", - "\n", - "### Flow inside `set_task()`:\n", - "\n", - "```\n", - "dataset.patients\n", - " \u2502\n", - " \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n", - " \u2551 for each patient (21,837 entries, 1 ECG each): \u2551\n", - " \u2551 \u2551\n", - " \u2551 1. scipy.io.loadmat(mat_path) \u2551\n", - " \u2551 \u2192 mat[\"val\"] shape (12, 5000) @ 500 Hz \u2551\n", - " \u2551 \u2192 /200.0 (ADC \u2192 millivolts) \u2551\n", - " \u2551 \u2551\n", - " \u2551 2. Decimate: signal[:, ::5] \u2551\n", - " \u2551 \u2192 shape (12, 1000) @ 100 Hz \u2551\n", - " \u2551 \u2551\n", - " \u2551 3. Parse SNOMED-CT codes \u2192 superdiagnostic labels \u2551\n", - " \u2551 \"426783006,251146004\" \u2192 [\"NORM\", \"HYP\"] \u2551\n", - " \u2551 (uses SNOMED_TO_SUPERDIAG: 46-code map) \u2551\n", - " \u2551 \u2551\n", - " \u2551 4. pickle.dump \u2192 cache/{ecg_id}.pkl \u2551\n", - " \u2551 5. Append sample dict to list \u2551\n", - " \u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\n", - " \u2502\n", - " \u25bc\n", - "SampleDataset.samples = [\n", - " {patient_id:\"HR00001\", ecg_id:\"HR00001\",\n", - " epoch_path:\"~/.cache/pyhealth_ptbxl/cinc_100hz/HR00001.pkl\",\n", - " \"labels\": [\"NORM\", \"HYP\"]}, \u2190 \"labels\" key (jtwells2 schema, plural)\n", - " {patient_id:\"HR00002\", ecg_id:\"HR00002\",\n", - " epoch_path:\"~/.cache/pyhealth_ptbxl/cinc_100hz/HR00002.pkl\",\n", - " \"labels\": [\"NORM\"]},\n", - " ... \u2190 ~21,666 samples total (171 skipped \u2014 no mappable diagnosis)\n", - "]\n", - "```\n", - "\n", - "### SNOMED_TO_SUPERDIAG \u2014 the 46-code mapping\n", - "\n", - "Source: `jtwells2/PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py`\n", - "\n", - "| Class | SNOMED codes mapped | Count |\n", - "|---|---|---|\n", - "| `NORM` | 426783006 | 1 |\n", - "| `MI` | 57054005, 164865005, 413444003, 413867000, 164861001, 164857002, 164860000, 164864009, 164867002 | 9 |\n", - "| `STTC` | 164931005, 164934002, 59931005, 164947007, 164917005, 251268003, 428750005 | 7 |\n", - "| `CD` | 270492004, 195042002, 27885002, 6374002, 713427006, 713426002, 164909002, 59118001, 698252002, 445118002, 10370003, 164889003, 164890007, 426627000, 427393009, 426177001, 427084000, 63593006, 17338001, 284470004, 427172004 | 21 |\n", - "| `HYP` | 55827005, 446358003, 73282002, 67751000119106, 446813000, 39732003, 47665007, 251146004 | 8 |" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7d06120b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calling dataset.set_task(ptbxl_superdiagnostic_fn) \u2026\n", - " Signal : full 10-second ECG, decimated 500\u2192100 Hz \u2192 (12, 1000)\n", - " Labels : 'labels' key [jtwells2 schema]\n", - " Mapping : SNOMED_TO_SUPERDIAG from ptbxl_multilabel_classification.py\n", - "\n", - "SampleSignalDataset: 21,767 samples (one per recording, no sliding windows)\n", - " input_info: {'signal': {'length': 1000, 'n_channels': 12}, 'label': {'type': , 'dim': 0}, 'labels': {'type': , 'dim': 2}}\n", - "\n", - "Label prevalence (jtwells2 SNOMED_TO_SUPERDIAG):\n", - " NORM 83.1% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " MI 30.5% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " STTC 15.9% \u2588\u2588\u2588\u2588\n", - " CD 37.7% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " HYP 26.2% \u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - "\n", - "Sample dict keys : ['patient_id', 'record_id', 'ecg_id', 'epoch_path', 'labels']\n", - " epoch_path : ...he/pyhealth_ptbxl/cinc_100hz/HR00001.pkl\n", - " labels : ['HYP', 'NORM']\n" - ] - } - ], - "source": [ - "\n", - "# \u2500\u2500 STEP 6: Task Function \u2014 aligned with jtwells2's PTBXLMultilabelClassification\n", - "#\n", - "# \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n", - "# \u2502 SOURCE FILE: PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py \u2502\n", - "# \u2502 CLASS: PTBXLMultilabelClassification(BaseTask) \u2502\n", - "# \u2502 AUTHOR: jtwells2 (CS-598 DLH Team) \u2502\n", - "# \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n", - "#\n", - "# jtwells2's __call__(patient) does exactly:\n", - "# 1. Load .mat signal (12, 5000) at 500 Hz\n", - "# 2. Decimate to 100 Hz: signal[:, ::5] \u2192 shape (12, 1000)\n", - "# OR keep 500 Hz: shape (12, 5000)\n", - "# 3. Parse SNOMED-CT codes from scp_codes attribute\n", - "# 4. Map codes \u2192 NORM / MI / STTC / CD / HYP via SNOMED_TO_SUPERDIAG\n", - "# 5. Return [{\"signal\": np.ndarray, \"labels\": List[str]}] (ONE per recording)\n", - "#\n", - "# KEY DIFFERENCES from our previous custom task function:\n", - "#\n", - "# OLD (custom task) NEW (jtwells2 aligned)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Sliding 2.5s windows @ 500Hz Full 10s recording, decimated to 100Hz\n", - "# ~7 windows per ECG \u2192 ~152k 1 sample per recording \u2192 ~19k samples\n", - "# \"label\" key (singular) \"labels\" key (plural, jtwells2 schema)\n", - "# 50-code hand-built SNOMED map jtwells2's 46-code clinically correct map\n", - "# confidence threshold none binary (same \u2014 CinC codes are all +ve)\n", - "# NORM mapped too broadly NORM = only 426783006 (correct NSR code)\n", - "#\n", - "# WHY epoch_path AND NOT direct signal array?\n", - "# Installed pyhealth 1.1.6 SampleSignalDataset.__getitem__ REQUIRES epoch_path\n", - "# for lazy signal loading. We write one .pkl per recording and store epoch_path\n", - "# identically to the installed pyhealth convention.\n", - "\n", - "from scipy.io import loadmat as scipy_loadmat\n", - "\n", - "# \u2500\u2500 SNOMED_TO_SUPERDIAG dict \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Direct copy from jtwells2's ptbxl_multilabel_classification.py\n", - "# Clinically correct mapping from Table 1 of Strodthoff et al. (2020)\n", - "SNOMED_TO_SUPERDIAG = {\n", - " # \u2500\u2500 NORM: Normal sinus rhythm only \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", - " \"426783006\": \"NORM\", # Normal sinus rhythm\n", - "\n", - " # \u2500\u2500 MI: Myocardial Infarction \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", - " \"57054005\": \"MI\", # Acute myocardial infarction\n", - " \"164865005\": \"MI\", # Myocardial infarction (generic)\n", - " \"413444003\": \"MI\", # Acute MI of anterolateral wall\n", - " \"413867000\": \"MI\", # Acute MI of inferior wall\n", - " \"164861001\": \"MI\", # Anterior MI\n", - " \"164857002\": \"MI\", # Inferior MI\n", - " \"164860000\": \"MI\", # Anteroseptal MI\n", - " \"164864009\": \"MI\", # Posterior MI\n", - " \"164867002\": \"MI\", # Lateral MI\n", - "\n", - " # \u2500\u2500 STTC: ST/T-wave Change \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", - " \"164931005\": \"STTC\", # ST elevation\n", - " \"164934002\": \"STTC\", # ST depression\n", - " \"59931005\": \"STTC\", # T-wave abnormality / inverted T-wave\n", - " \"164947007\": \"STTC\", # Prolonged PR interval\n", - " \"164917005\": \"STTC\", # Prolonged QT interval\n", - " \"251268003\": \"STTC\", # Early repolarisation pattern\n", - " \"428750005\": \"STTC\", # Non-specific ST-T change\n", - "\n", - " # \u2500\u2500 CD: Conduction Disturbance / Rhythm Disorder \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", - " \"270492004\": \"CD\", # First-degree AV block\n", - " \"195042002\": \"CD\", # Second-degree AV block\n", - " \"27885002\": \"CD\", # Third-degree AV block (complete heart block)\n", - " \"6374002\": \"CD\", # Bundle branch block (unspecified)\n", - " \"713427006\": \"CD\", # Complete right bundle branch block (CRBBB)\n", - " \"713426002\": \"CD\", # Complete left bundle branch block (CLBBB)\n", - " \"164909002\": \"CD\", # Left bundle branch block\n", - " \"59118001\": \"CD\", # Right bundle branch block\n", - " \"698252002\": \"CD\", # Non-specific intraventricular conduction disturbance\n", - " \"445118002\": \"CD\", # Left anterior fascicular block (LAFB)\n", - " \"10370003\": \"CD\", # Pacing rhythm\n", - " \"164889003\": \"CD\", # Atrial fibrillation\n", - " \"164890007\": \"CD\", # Atrial flutter\n", - " \"426627000\": \"CD\", # Bradycardia\n", - " \"427393009\": \"CD\", # Sinus arrhythmia\n", - " \"426177001\": \"CD\", # Sinus bradycardia\n", - " \"427084000\": \"CD\", # Sinus tachycardia\n", - " \"63593006\": \"CD\", # Supraventricular premature beats\n", - " \"17338001\": \"CD\", # Ventricular premature beats\n", - " \"284470004\": \"CD\", # Premature atrial contraction\n", - " \"427172004\": \"CD\", # Premature ventricular contraction\n", - "\n", - " # \u2500\u2500 HYP: Hypertrophy / Axis Deviation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 #\n", - " \"55827005\": \"HYP\", # Left ventricular hypertrophy\n", - " \"446358003\": \"HYP\", # Right ventricular hypertrophy\n", - " \"73282002\": \"HYP\", # Biventricular hypertrophy\n", - " \"67751000119106\": \"HYP\", # Left atrial enlargement\n", - " \"446813000\": \"HYP\", # Right atrial enlargement\n", - " \"39732003\": \"HYP\", # Left axis deviation\n", - " \"47665007\": \"HYP\", # Right axis deviation\n", - " \"251146004\": \"HYP\", # Low QRS voltage\n", - "}\n", - "\n", - "# Ordered class list \u2014 from jtwells2's SUPERDIAG_CLASSES\n", - "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", - "\n", - "\n", - "# \u2500\u2500 Task function \u2014 mirrors PTBXLMultilabelClassification.__call__() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def ptbxl_superdiagnostic_fn(\n", - " record_list: list,\n", - " sampling_rate: int = 100, # jtwells2 default\n", - " native_freq: int = 500, # CinC 2020 native rate\n", - ") -> list:\n", - " \"\"\"\n", - " Task function aligned with jtwells2's PTBXLMultilabelClassification.__call__().\n", - "\n", - " SIGNAL: full 10-second ECG decimated to 100 Hz \u2192 shape (12, 1000)\n", - " Matches jtwells2: signal = mat[\"val\"] ; signal[:, ::5]\n", - "\n", - " LABELS: \"labels\" key (plural) \u2192 List[str] of superdiagnostic class names\n", - " Matches jtwells2 output schema: {\"signal\": ..., \"labels\": [...]}\n", - "\n", - " STORAGE: cached as .pkl files (epoch_path key) for installed pyhealth\n", - " SampleSignalDataset which requires lazy loading via epoch_path.\n", - " \"\"\"\n", - " samples = []\n", - " decimate = native_freq // sampling_rate # 5\n", - " expected_len = 5000 // decimate # 1000 samples\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"cinc_{sampling_rate}hz\"\n", - " cache_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - " for visit in record_list:\n", - " pid = visit[\"patient_id\"]\n", - " ecg_id = visit[\"ecg_id\"]\n", - " mat_path = visit[\"mat_path\"]\n", - "\n", - " # \u2500\u2500 1. Parse SNOMED-CT codes \u2192 superdiagnostic labels \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " raw = str(visit[\"scp_codes\"])\n", - " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", - " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", - " if not labels:\n", - " continue # skip recordings with no mappable diagnosis\n", - "\n", - " # \u2500\u2500 2. Load signal (mirrors jtwells2's scipy.io.loadmat(signal_file)) \u2500\n", - " if mat_path and Path(mat_path).exists():\n", - " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0 # ADC \u2192 mV, (12, 5000)\n", - " else:\n", - " t = np.linspace(0, 10, native_freq * 10)\n", - " lead = 0.5*np.sin(2*np.pi*1.2*t) + np.random.randn(native_freq*10)*0.04\n", - " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", - "\n", - " # \u2500\u2500 3. Decimate to target sampling rate (mirrors jtwells2: signal[:, ::5])\n", - " signal = signal[:, ::decimate] # \u2192 (12, 1000)\n", - "\n", - " if signal.shape[1] < expected_len:\n", - " continue # malformed recording \u2014 skip\n", - "\n", - " # \u2500\u2500 4. Cache as .pkl \u2014 required by installed pyhealth SampleSignalDataset\n", - " pkl_path = str(cache_dir / f\"{ecg_id}.pkl\")\n", - " if not Path(pkl_path).exists(): # skip if already cached\n", - " with open(pkl_path, \"wb\") as f:\n", - " pickle.dump({\"signal\": signal}, f)\n", - "\n", - " samples.append({\n", - " \"patient_id\": pid,\n", - " \"record_id\": ecg_id,\n", - " \"ecg_id\": ecg_id,\n", - " \"epoch_path\": pkl_path, # installed SampleSignalDataset requirement\n", - " \"labels\": labels, # \"labels\" key \u2014 jtwells2 schema\n", - " })\n", - " return samples\n", - "\n", - "\n", - "# \u2500\u2500 Apply task \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "print(\"Calling dataset.set_task(ptbxl_superdiagnostic_fn) \u2026\")\n", - "print(\" Signal : full 10-second ECG, decimated 500\u2192100 Hz \u2192 (12, 1000)\")\n", - "print(\" Labels : 'labels' key [jtwells2 schema]\")\n", - "print(\" Mapping : SNOMED_TO_SUPERDIAG from ptbxl_multilabel_classification.py\\n\")\n", - "\n", - "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "sample_dataset.input_info[\"labels\"] = {\"type\": str, \"dim\": 2} # \"labels\" key\n", - "\n", - "n = len(sample_dataset)\n", - "pos_rates = np.zeros(len(SUPERDIAG_CLASSES))\n", - "for s in sample_dataset.samples:\n", - " for cls in s[\"labels\"]:\n", - " if cls in SUPERDIAG_CLASSES:\n", - " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", - "pos_rates /= max(n, 1)\n", - "\n", - "print(f\"SampleSignalDataset: {n:,} samples (one per recording, no sliding windows)\")\n", - "print(f\" input_info: {sample_dataset.input_info}\")\n", - "print(f\"\\nLabel prevalence (jtwells2 SNOMED_TO_SUPERDIAG):\")\n", - "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", - " bar = \"\u2588\" * int(rate * 30)\n", - " print(f\" {cls:<6} {rate*100:5.1f}% {bar}\")\n", - "\n", - "# Verify schema matches jtwells2's PTBXLMultilabelClassification output\n", - "sample0 = sample_dataset.samples[0]\n", - "print(f\"\\nSample dict keys : {list(sample0.keys())}\")\n", - "print(f\" epoch_path : ...{sample0['epoch_path'][-40:]}\")\n", - "print(f\" labels : {sample0['labels']}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "f775ce31", - "metadata": {}, - "source": [ - "---\n", - "## Section 7 \u2014 Visualize a Sample Window and its Multi-hot Label" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b1a0802", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " signal shape : (12, 1000) (12 leads \u00d7 1000 samples @ 100 Hz = 10 s)\n", - " labels : ['HYP', 'NORM']\n", - " multi-hot : [1.0, 0.0, 0.0, 0.0, 1.0] [NORM, MI, STTC, CD, HYP]\n", - " SNOMED-CT Dx : 251146004,426783006\n", - "\n", - " Schema key 'labels' (plural) matches jtwells2 :: PTBXLMultilabelClassification\n" - ] - } - ], - "source": [ - "\n", - "# \u2500\u2500 STEP 7: Visualize a sample window and its multi-hot label \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# Schema after jtwells2 alignment:\n", - "# sample[\"epoch_path\"] .pkl file with {\"signal\": np.float32(12, 1000)}\n", - "# sample[\"labels\"] List[str] e.g. [\"NORM\"] or [\"CD\", \"MI\"]\n", - "# (key is \"labels\", NOT \"label\")\n", - "#\n", - "# Signal shape is now (12, 1000) at 100 Hz (full 10-second recording),\n", - "# vs the old (12, 1250) at 500 Hz (2.5-second window). This matches\n", - "# jtwells2's PTBXLMultilabelClassification with sampling_rate=100.\n", - "\n", - "def visualize_sample(sample: dict):\n", - " \"\"\"Plot the 12-lead ECG and multi-hot label bar for one sample.\"\"\"\n", - " # \u2500\u2500 Load signal from epoch_path pickle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " with open(sample[\"epoch_path\"], \"rb\") as f:\n", - " data = pickle.load(f)\n", - "\n", - " signal = data[\"signal\"] # (12, 1000) float32 @ 100 Hz\n", - " label_list = sample[\"labels\"] # \u2190 \"labels\" key (jtwells2 schema)\n", - "\n", - " # Convert List[str] \u2192 multi-hot for the bar chart\n", - " label_vec = [1.0 if cls in label_list else 0.0 for cls in SUPERDIAG_CLASSES]\n", - "\n", - " fig = plt.figure(figsize=(15, 9))\n", - " gs = gridspec.GridSpec(2, 1, figure=fig, height_ratios=[4, 1], hspace=0.4)\n", - "\n", - " # \u2500\u2500 Top: 12-lead ECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " gs_top = gridspec.GridSpecFromSubplotSpec(6, 2, subplot_spec=gs[0],\n", - " hspace=0.05, wspace=0.3)\n", - " lead_names = [\"I\",\"II\",\"III\",\"aVR\",\"aVL\",\"aVF\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\"]\n", - " fs = 100 # jtwells2: 100 Hz\n", - " t_axis = np.arange(signal.shape[1]) / fs # 0 \u2026 10 seconds\n", - "\n", - " for i in range(12):\n", - " row, col = divmod(i, 2)\n", - " ax = fig.add_subplot(gs_top[row, col])\n", - " ax.plot(t_axis, signal[i], linewidth=0.8, color=\"#1f77b4\")\n", - " ax.set_ylabel(lead_names[i], fontsize=8, rotation=0, labelpad=18)\n", - " ax.set_yticks([])\n", - " if row < 5:\n", - " ax.set_xticks([])\n", - " else:\n", - " ax.set_xlabel(\"Time (s)\", fontsize=8)\n", - "\n", - " # scp_codes is a SNOMED-CT string in CinC format\n", - " patient_scp = dataset.patients[sample[\"patient_id\"]][0][\"scp_codes\"]\n", - " fig.text(\n", - " 0.5, 0.97,\n", - " f\"Full 10-second ECG @ 100 Hz \u2014 patient {sample['patient_id']} \"\n", - " f\"| shape: {signal.shape} (12 leads \u00d7 1000 samples)\",\n", - " ha=\"center\", fontsize=11, fontweight=\"bold\",\n", - " )\n", - "\n", - " # \u2500\u2500 Bottom: multi-hot label bar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " ax_lbl = fig.add_subplot(gs[1])\n", - " colors = [\"#2ecc71\" if v else \"#e74c3c\" for v in label_vec]\n", - " bars = ax_lbl.bar(SUPERDIAG_CLASSES, label_vec,\n", - " color=colors, edgecolor=\"white\", width=0.6)\n", - " for bar_, val in zip(bars, label_vec):\n", - " ax_lbl.text(\n", - " bar_.get_x() + bar_.get_width() / 2, val + 0.03,\n", - " \"\u2713 ACTIVE\" if val else \"\u2717 absent\",\n", - " ha=\"center\", va=\"bottom\", fontsize=9,\n", - " color=\"#2ecc71\" if val else \"#aaaaaa\",\n", - " )\n", - " ax_lbl.set_ylim(0, 1.5)\n", - " ax_lbl.set_ylabel(\"Label (0/1)\", fontsize=9)\n", - " ax_lbl.set_title(\n", - " f\"'labels': {label_list} | SNOMED-CT Dx: {patient_scp}\",\n", - " fontsize=9,\n", - " )\n", - " ax_lbl.set_yticks([0, 1])\n", - " ax_lbl.legend(handles=[\n", - " mpatches.Patch(color=\"#2ecc71\", label=\"Active class (label=1)\"),\n", - " mpatches.Patch(color=\"#e74c3c\", label=\"Inactive (label=0)\"),\n", - " ], loc=\"upper right\", fontsize=8)\n", - "\n", - " plt.show()\n", - "\n", - " # Summary\n", - " print(f\" signal shape : {signal.shape} (12 leads \u00d7 1000 samples @ 100 Hz = 10 s)\")\n", - " print(f\" labels : {label_list}\")\n", - " print(f\" multi-hot : {label_vec} [{', '.join(SUPERDIAG_CLASSES)}]\")\n", - " print(f\" SNOMED-CT Dx : {patient_scp}\")\n", - " print(f\"\\n Schema key 'labels' (plural) matches jtwells2 :: PTBXLMultilabelClassification\")\n", - "\n", - "\n", - "visualize_sample(sample_dataset.samples[0])\n" - ] - }, - { - "cell_type": "markdown", - "id": "4473b9e4", - "metadata": {}, - "source": [ - "---\n", - "## Section 8 \u2014 Split Dataset by Patient (Train / Val / Test)\n", - "\n", - "### Why split by Patient, not by Sample?\n", - "\n", - "If you split randomly by sample, windows from the **same patient** can appear in both \n", - "train and test. The model memorizes the patient's signal rather than learning the disease. \n", - "This is **data leakage** \u2014 test accuracy looks high but won't generalize.\n", - "\n", - "**The correct approach:** split the `patients` dict first, then gather all samples from each group.\n", - "\n", - "```\n", - "All 18,885 patients\n", - " \u251c\u2500\u2500 Train patients (80%) \u2192 all their windows \u2192 Train split\n", - " \u251c\u2500\u2500 Val patients (10%) \u2192 all their windows \u2192 Val split\n", - " \u2514\u2500\u2500 Test patients (10%) \u2192 all their windows \u2192 Test split\n", - "\n", - "Guarantee: \u2200 p \u2208 train_pids: p \u2209 val_pids AND p \u2209 test_pids\n", - "```\n", - "\n", - "The original paper uses **stratified folds 1\u201310** (fold 9 for val, fold 10 for test). \n", - "PyHealth's `split_by_patient()` uses random patient-level assignment instead (same principle)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "036f2200", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u26a1 Working with 2,000 records (subsampled, seed=42).\n", - "\n", - "Patient-level split (80/10/10, seed=42):\n", - " Train : 1,600 samples | 50 batches/epoch\n", - " Val : 200 samples\n", - " Test : 200 samples\n", - " Batch size : 32\n", - "\n", - "Batch keys : ['patient_id', 'record_id', 'ecg_id', 'labels', 'signal']\n", - " signal[0] : (12, 1000) dtype=float32 (12 leads \u00d7 1000 samples @ 100 Hz)\n", - " labels[0] : ['CD', 'NORM']\n", - "\n", - "\u2705 Zero patient overlap across splits.\n", - " Unique patients \u2014 Train: 1,600 | Val: 200 | Test: 200\n" - ] - } - ], - "source": [ - "# \u2500\u2500 STEP 8: Patient-level split + PyHealth DataLoaders \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# IMPORTANT: Cells 34-50 redefine `split_by_patient`, `get_dataloader`, etc.\n", - "# in the kernel namespace. We use fully-qualified aliases here so this cell\n", - "# is safe to re-run in any kernel state.\n", - "\n", - "import pyhealth.datasets as _ph_ds\n", - "from torch.utils.data import DataLoader as _DL, Subset as _Subset\n", - "\n", - "# \u2500\u2500 Subsample for faster iteration (N_SUBSAMPLE=None \u2192 full ~21k dataset) \u2500\u2500\u2500\u2500\n", - "N_SUBSAMPLE = 2_000 # ULTRA-FAST TEST \u2190 change to 10_000 or None as needed\n", - "\n", - "n_full = len(sample_dataset.samples)\n", - "rng = np.random.default_rng(seed=42)\n", - "all_idx = sorted(\n", - " rng.choice(n_full, size=min(N_SUBSAMPLE, n_full), replace=False).tolist()\n", - ") if N_SUBSAMPLE and N_SUBSAMPLE < n_full else list(range(n_full))\n", - "\n", - "print(f\"\u26a1 Working with {len(all_idx):,} records \"\n", - " f\"({'subsampled' if len(all_idx) < n_full else 'full dataset'}, seed=42).\")\n", - "\n", - "# \u2500\u2500 Patient-level split (inline \u2014 immune to name collision) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "pid_to_pos = {}\n", - "for pos, idx in enumerate(all_idx):\n", - " pid = sample_dataset.samples[idx][\"patient_id\"]\n", - " pid_to_pos.setdefault(pid, []).append(pos)\n", - "\n", - "pids = list(pid_to_pos.keys())\n", - "np.random.default_rng(42).shuffle(pids)\n", - "n_p = len(pids)\n", - "n_tr = int(0.80 * n_p)\n", - "n_vl = int(0.10 * n_p)\n", - "\n", - "tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", - "vl_pos = [p for pid in pids[n_tr:n_tr+n_vl] for p in pid_to_pos[pid]]\n", - "te_pos = [p for pid in pids[n_tr+n_vl:] for p in pid_to_pos[pid]]\n", - "\n", - "# Map positions back to original sample_dataset indices\n", - "tr_idx = [all_idx[p] for p in tr_pos]\n", - "vl_idx = [all_idx[p] for p in vl_pos]\n", - "te_idx = [all_idx[p] for p in te_pos]\n", - "\n", - "train_ds = _Subset(sample_dataset, tr_idx)\n", - "val_ds = _Subset(sample_dataset, vl_idx)\n", - "test_ds = _Subset(sample_dataset, te_idx)\n", - "\n", - "# \u2500\u2500 DataLoaders with pyhealth's collate_fn_dict \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# collate_fn_dict \u2192 {key: [d[key] for d in batch]}\n", - "# signal stays as List[np.ndarray] \u2014 consumed by model forward() via np.array()\n", - "BATCH_SIZE = 32\n", - "train_loader = _DL(train_ds, batch_size=BATCH_SIZE, shuffle=True,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "val_loader = _DL(val_ds, batch_size=BATCH_SIZE, shuffle=False,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "test_loader = _DL(test_ds, batch_size=BATCH_SIZE, shuffle=False,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "\n", - "print(f\"\\nPatient-level split (80/10/10, seed=42):\")\n", - "print(f\" Train : {len(tr_idx):>6,} samples | {len(train_loader)} batches/epoch\")\n", - "print(f\" Val : {len(vl_idx):>6,} samples\")\n", - "print(f\" Test : {len(te_idx):>6,} samples\")\n", - "print(f\" Batch size : {BATCH_SIZE}\")\n", - "\n", - "# \u2500\u2500 Peek at one batch \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "batch = next(iter(train_loader))\n", - "sig_ex = np.array(batch[\"signal\"][0])\n", - "print(f\"\\nBatch keys : {list(batch.keys())}\")\n", - "print(f\" signal[0] : {sig_ex.shape} dtype={sig_ex.dtype} \"\n", - " f\"(12 leads \u00d7 1000 samples @ 100 Hz)\")\n", - "print(f\" labels[0] : {batch['labels'][0]}\")\n", - "\n", - "# \u2500\u2500 Leak check \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "tr_pids = {sample_dataset.samples[i][\"patient_id\"] for i in tr_idx}\n", - "vl_pids = {sample_dataset.samples[i][\"patient_id\"] for i in vl_idx}\n", - "te_pids = {sample_dataset.samples[i][\"patient_id\"] for i in te_idx}\n", - "assert not (tr_pids & vl_pids), \"LEAKAGE: train \u2229 val!\"\n", - "assert not (tr_pids & te_pids), \"LEAKAGE: train \u2229 test!\"\n", - "assert not (vl_pids & te_pids), \"LEAKAGE: val \u2229 test!\"\n", - "print(f\"\\n\u2705 Zero patient overlap across splits.\")\n", - "print(f\" Unique patients \u2014 Train: {len(tr_pids):,} | Val: {len(vl_pids):,} | Test: {len(te_pids):,}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "bc3ef579", - "metadata": {}, - "source": [ - "\n", - "### Models implemented in this notebook\n", - "\n", - "This notebook implements and benchmarks **two architectures**:\n", - "\n", - "| Model | Class | Source | Params |\n", - "|---|---|---|---|\n", - "| **SparcNet** | `pyhealth.models.SparcNet` | Built-in PyHealth (DenseNet-inspired 1D TCN) | ~1.2M |\n", - "| **BiLSTMECG** | Custom `BaseModel` subclass | Defined in this notebook | ~300K |\n", - "\n", - "Both accept `(B, 12, 1000)` input (12 leads \u00d7 1000 samples @ 100 Hz) and output `(B, 5)` logits for the 5 superdiagnostic classes.\n", - "\n", - "> The original PTB-XL benchmark paper (Strodthoff et al., 2020) evaluated **9 architectures** (ResNet1d, BiLSTM, EfficientNet1d, MobileNetV3, NFNet1d, SENet1d, SqueezeNet1d, LambdaNet1d, Transformer). This notebook focuses on SparcNet and BiLSTMECG as a reproducible two-model ablation.\n", - "\n", - "### SparcNet architecture\n", - "\n", - "SparcNet is a **densely-connected 1D temporal convolutional network** (adapted from SparcNet / DenseNet for ECG):\n", - "\n", - "```\n", - "Input (B, 12, 1000)\n", - " \u2192 DenseBlock \u00d7 4 (1D depthwise + pointwise conv, dropout)\n", - " \u2192 Global Average Pooling \u2192 (B, 256)\n", - " \u2192 Linear(256 \u2192 5)\n", - " \u2192 BCEWithLogitsLoss (sigmoid applied internally)\n", - "```\n", - "\n", - "### BiLSTMECG architecture\n", - "\n", - "```\n", - "Input (B, 12, 1000)\n", - " \u2192 permute \u2192 (B, 1000, 12) # time-first for LSTM\n", - " \u2192 BiLSTM(in=12, hidden=128, layers=3, bidirectional=True)\n", - " \u2192 last timestep \u2192 (B, 256) # hidden*2 because bidirectional\n", - " \u2192 Linear(256 \u2192 5)\n", - " \u2192 BCEWithLogitsLoss\n", - "```\n", - "\n", - "Both models use **`label_key=\"labels\"`** (jtwells2 plural schema) and `mode=\"multilabel\"` so PyHealth's `BaseModel` automatically applies `BCEWithLogitsLoss`." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "90b71e50", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "=== Input data statistics ===\n", - "n_channels: 12\n", - "length: 1000\n", - "Model A \u2014 PyHealth SparcNet\n", - " Trainable params : 952,834\n", - " Input shape : (B, 12, 1000) \u2014 12 leads \u00d7 1000 samples @ 100 Hz\n", - " Output shape : (B, 5) \u2014 ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", - "\n", - "Model B \u2014 BiLSTMECG (paper-aligned: AdaptiveAvgPool1d over ALL timesteps)\n", - " Variant : lstm_d1_h64 (paper's reported best config)\n", - " Trainable params : 40,581\n", - " Architecture : BiLSTM(12\u219264, \u00d71) \u2192 AvgPool(all T) \u2192 FC(128\u21925)\n", - " Pooling : AdaptiveAvgPool1d(1) [paper bi_lstm.py aligned]\n", - "\n", - "Smoke test (batch_size=32):\n", - " SparcNet logit: (32, 5) loss: 0.6996\n", - " BiLSTMECG logit: (32, 5) loss: 0.7091\n", - "\n", - "\u2705 BiLSTMECG uses AdaptiveAvgPool1d(1) \u2014 matches paper bi_lstm.py exactly.\n" - ] - } - ], - "source": [ - "\n", - "# \u2500\u2500 STEP 9: PyHealth Models \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "import math\n", - "from collections import OrderedDict\n", - "\n", - "# \u2500\u2500 Model A: SparcNet \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "sparcnet = SparcNet(\n", - " dataset = sample_dataset,\n", - " feature_keys = [\"signal\"],\n", - " label_key = \"labels\",\n", - " mode = \"multilabel\",\n", - ")\n", - "\n", - "print(\"Model A \u2014 PyHealth SparcNet\")\n", - "n_params_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", - "print(f\" Trainable params : {n_params_sparcnet:,}\")\n", - "print(f\" Input shape : (B, 12, 1000) \u2014 12 leads \u00d7 1000 samples @ 100 Hz\")\n", - "print(f\" Output shape : (B, {len(SUPERDIAG_CLASSES)}) \u2014 {SUPERDIAG_CLASSES}\")\n", - "\n", - "\n", - "# \u2500\u2500 Model B: BiLSTMECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Paper-aligned: Nonaka & Seita (2021) bi_lstm.py\n", - "#\n", - "# Paper's forward() in seitalab/dnn_ecg_comparison/bi_lstm.py:\n", - "# x: (B, 12, T) \u2192 permute(2,0,1) [seq-first]\n", - "# \u2192 BiLSTM \u2192 feat (T, B, hidden*2)\n", - "# \u2192 permute(1,2,0) \u2192 (B, hidden*2, T)\n", - "# \u2192 AdaptiveAvgPool1d(1) \u2192 (B, hidden*2, 1)\n", - "# \u2192 squeeze(-1) \u2192 (B, hidden*2)\n", - "# \u2192 Linear(hidden*2, backbone_out_dim)\n", - "#\n", - "# Our version uses batch_first=True \u2014 mathematically identical.\n", - "class BiLSTMECG(BaseModel):\n", - " \"\"\"\n", - " Bidirectional LSTM \u2014 paper-aligned (Nonaka & Seita 2021).\n", - "\n", - " FIXED: Uses AdaptiveAvgPool1d(1) over ALL timesteps (paper-aligned),\n", - " NOT out[:, -1, :] (last-timestep only \u2014 incorrect).\n", - " \"\"\"\n", - " def __init__(\n", - " self,\n", - " dataset,\n", - " feature_keys,\n", - " label_key,\n", - " mode,\n", - " hidden_size: int = 128,\n", - " n_layers: int = 3,\n", - " dropout: float = 0.2,\n", - " **kwargs,\n", - " ):\n", - " super().__init__(\n", - " dataset = dataset,\n", - " feature_keys = feature_keys,\n", - " label_key = label_key,\n", - " mode = mode,\n", - " )\n", - " sig_info = self.dataset.input_info[\"signal\"]\n", - " in_channels = sig_info[\"n_channels\"] # 12\n", - "\n", - " self.label_tokenizer = self.get_label_tokenizer()\n", - " output_size = self.get_output_size(self.label_tokenizer)\n", - "\n", - " self.lstm = nn.LSTM(\n", - " input_size = in_channels,\n", - " hidden_size = hidden_size,\n", - " num_layers = n_layers,\n", - " bidirectional = True,\n", - " batch_first = True,\n", - " dropout = dropout if n_layers > 1 else 0.0,\n", - " )\n", - " # Paper's aggregation: AdaptiveAvgPool1d over ALL timesteps\n", - " self.pool = nn.AdaptiveAvgPool1d(1)\n", - " self.fc = nn.Linear(hidden_size * 2, output_size)\n", - "\n", - " def forward(self, **kwargs) -> dict:\n", - " x = torch.tensor(\n", - " np.array(kwargs[self.feature_keys[0]]),\n", - " device=self.device,\n", - " ).float() # (B, 12, T)\n", - "\n", - " out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2)\n", - " # Paper: feat.permute(1,2,0) \u2192 AdaptiveAvgPool1d(1) \u2192 squeeze(-1)\n", - " pooled = self.pool(out.permute(0, 2, 1)).squeeze(-1) # (B, hidden*2)\n", - " logits = self.fc(pooled) # (B, K)\n", - "\n", - " y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer)\n", - " loss = self.get_loss_function()(logits, y_true)\n", - " y_prob = self.prepare_y_prob(logits)\n", - " return {\"loss\": loss, \"y_prob\": y_prob, \"y_true\": y_true, \"logit\": logits}\n", - "\n", - "\n", - "bilstm = BiLSTMECG(\n", - " dataset = sample_dataset,\n", - " feature_keys = [\"signal\"],\n", - " label_key = \"labels\",\n", - " mode = \"multilabel\",\n", - " hidden_size = 64, # lstm_d1_h64 \u2014 paper's best variant\n", - " n_layers = 1,\n", - ")\n", - "\n", - "print(\"\\nModel B \u2014 BiLSTMECG (paper-aligned: AdaptiveAvgPool1d over ALL timesteps)\")\n", - "print(\" Variant : lstm_d1_h64 (paper's reported best config)\")\n", - "n_params_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", - "print(f\" Trainable params : {n_params_bilstm:,}\")\n", - "print(f\" Architecture : BiLSTM(12\u219264, \u00d71) \u2192 AvgPool(all T) \u2192 FC(128\u2192{len(SUPERDIAG_CLASSES)})\")\n", - "print(f\" Pooling : AdaptiveAvgPool1d(1) [paper bi_lstm.py aligned]\")\n", - "\n", - "# \u2500\u2500 Smoke test \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "with torch.no_grad():\n", - " test_batch = next(iter(train_loader))\n", - " out_s = sparcnet(**test_batch)\n", - " out_b = bilstm(**test_batch)\n", - "\n", - "print(f\"\\nSmoke test (batch_size={BATCH_SIZE}):\")\n", - "print(f\" SparcNet logit: {tuple(out_s['logit'].shape)} loss: {out_s['loss'].item():.4f}\")\n", - "print(f\" BiLSTMECG logit: {tuple(out_b['logit'].shape)} loss: {out_b['loss'].item():.4f}\")\n", - "print(f\"\\n\u2705 BiLSTMECG uses AdaptiveAvgPool1d(1) \u2014 matches paper bi_lstm.py exactly.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "3fa22098", - "metadata": {}, - "source": [ - "\n", - "### What the Trainer does\n", - "\n", - "```\n", - "Trainer.__init__(model, optimizer=\"Adam\", loss_fn=BCEWithLogitsLoss)\n", - " \u2502\n", - " \u25bc\n", - "trainer.train(train_loader, val_loader, epochs=5)\n", - " \u2502\n", - " \u251c\u2500\u2500 for each epoch:\n", - " \u2502 \u251c\u2500\u2500 for each mini-batch (B=32):\n", - " \u2502 \u2502 \u251c\u2500\u2500 load signal from sample[\"epoch_path\"] (pkl file)\n", - " \u2502 \u2502 \u251c\u2500\u2500 forward pass \u2192 logits (B, 5)\n", - " \u2502 \u2502 \u251c\u2500\u2500 BCEWithLogitsLoss(logits, multi-hot labels)\n", - " \u2502 \u2502 \u251c\u2500\u2500 loss.backward()\n", - " \u2502 \u2502 \u2514\u2500\u2500 optimizer.step()\n", - " \u2502 \u2502\n", - " \u2502 \u2514\u2500\u2500 evaluate on val_loader after each epoch\n", - " \u2502 \u2192 compute macro ROC-AUC\n", - " \u2502 \u2192 EarlyStopper: save checkpoint if improved\n", - " \u2502\n", - " \u2514\u2500\u2500 restore best checkpoint (highest val ROC-AUC)\n", - "```\n", - "\n", - "**Loss function:** `BCEWithLogitsLoss` \u2014 binary cross-entropy with built-in sigmoid, \n", - "applied **independently** to each of the 5 output neurons. \n", - "This is correct for multi-label because a recording can activate multiple classes simultaneously.\n", - "\n", - "> **Training budget in this demo:** 5 epochs only (for speed). The original PTB-XL paper trains for 100+ epochs. Results here (~0.50 macro ROC-AUC) reflect under-training; extending to 30\u201350 epochs with MPS acceleration would substantially improve performance (see bottleneck analysis at end of notebook)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "156a0428", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - " Training SparcNet [3 epochs, N=1600 samples]\n", - "============================================================\n", - "SparcNet(\n", - " (encoder): Sequential(\n", - " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", - " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu0): ELU(alpha=1.0)\n", - " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (denseblock1): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition1): TransitionLayer(\n", - " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock2): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition2): TransitionLayer(\n", - " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock3): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition3): TransitionLayer(\n", - " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock4): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition4): TransitionLayer(\n", - " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock5): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition5): TransitionLayer(\n", - " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock6): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition6): TransitionLayer(\n", - " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock7): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition7): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " )\n", - " (fc): Linear(in_features=63, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.32it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.5967\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.88it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.5026\n", - "f1_macro: 0.4728\n", - "loss: 0.5809\n", - "New best roc_auc_macro score (0.5026) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:20<00:00, 2.39it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5631\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.82it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.5011\n", - "f1_macro: 0.3915\n", - "loss: 0.5574\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.36it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5574\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.82it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.5255\n", - "f1_macro: 0.4721\n", - "loss: 0.5781\n", - "New best roc_auc_macro score (0.5255) at epoch-2, step-150\n", - "Loaded best model\n", - "\n", - "SparcNet training complete.\n", - "Best checkpoint: ./output/ptbxl/sparcnet_superdiag_5class/best.ckpt\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# \u2500\u2500 STEP 10: Train SparcNet with PyHealth's Trainer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "\n", - "TRAIN_EPOCHS = 3 # ultra-fast test; change to 25 for results-quality run\n", - "\n", - "print(\"=\" * 60)\n", - "print(f\" Training SparcNet [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", - "print(\"=\" * 60)\n", - "\n", - "trainer_sparcnet = Trainer(\n", - " model = sparcnet,\n", - " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", - " enable_logging = True,\n", - " output_path = \"./output/ptbxl\",\n", - " exp_name = \"sparcnet_superdiag_5class\",\n", - ")\n", - "\n", - "trainer_sparcnet.train(\n", - " train_dataloader = train_loader,\n", - " val_dataloader = val_loader,\n", - " epochs = TRAIN_EPOCHS,\n", - " optimizer_params = {\"lr\": 1e-3},\n", - " weight_decay = 1e-4,\n", - " monitor = \"roc_auc_macro\",\n", - " monitor_criterion = \"max\",\n", - " load_best_model_at_last = True,\n", - ")\n", - "\n", - "print(\"\\nSparcNet training complete.\")\n", - "print(\"Best checkpoint: ./output/ptbxl/sparcnet_superdiag_5class/best.ckpt\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "fabe80f0", - "metadata": {}, - "source": [ - "---\n", - "## Section 11 \u2014 Evaluate: ROC-AUC macro and F1 macro\n", - "\n", - "### Why these two metrics?\n", - "\n", - "| Metric | What it measures | Used by |\n", - "|---|---|---|\n", - "| **ROC-AUC macro** | Ranking quality \u2014 how well the model orders positives above negatives, averaged across classes. Threshold-independent. | Primary metric in the original paper |\n", - "| **F1 macro** | Precision-recall balance at 0.5 threshold, averaged across classes. Penalizes false negatives equally. | Standard complement to AUC |\n", - "\n", - "For **multi-label**: both metrics are computed **per class** then macro-averaged (unweighted mean). \n", - "A class with only 5 positives counts equally to a class with 5,000 positives \u2014 macro averaging is strict." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "85ff3ccc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - " SparcNet \u2014 Test Set Evaluation (PyHealth Trainer.evaluate)\n", - "============================================================\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.75it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Test ROC-AUC (macro) : 0.4802\n", - " Test F1 (macro) : 0.4717\n", - " Test Loss : 0.5819\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 2.82it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Per-class ROC-AUC:\n", - " NORM 0.5029 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " MI 0.4328 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " STTC 0.4636 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " CD 0.5046 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n", - " HYP 0.4969 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# \u2500\u2500 STEP 11: Evaluate SparcNet on the held-out test set \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# Trainer.evaluate(dataloader):\n", - "# 1. Runs inference in no_grad mode over every batch\n", - "# 2. Collects y_true (multi-hot from prepare_labels) and y_prob (sigmoid)\n", - "# 3. Calls multilabel_metrics_fn(y_true, y_prob) to compute:\n", - "# roc_auc_macro \u2014 primary metric used in the DLH paper\n", - "# f1_macro \u2014 secondary metric\n", - "# loss \u2014 mean BCE loss on test set\n", - "\n", - "print(\"=\" * 60)\n", - "print(\" SparcNet \u2014 Test Set Evaluation (PyHealth Trainer.evaluate)\")\n", - "print(\"=\" * 60)\n", - "\n", - "sparcnet_scores = trainer_sparcnet.evaluate(test_loader)\n", - "\n", - "print(f\"\\n Test ROC-AUC (macro) : {sparcnet_scores['roc_auc_macro']:.4f}\")\n", - "print(f\" Test F1 (macro) : {sparcnet_scores['f1_macro']:.4f}\")\n", - "print(f\" Test Loss : {sparcnet_scores['loss']:.4f}\")\n", - "\n", - "# \u2500\u2500 Per-class breakdown using y_prob and y_true from inference \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "y_true_all, y_prob_all, _ = trainer_sparcnet.inference(test_loader)\n", - "# y_true_all, y_prob_all are numpy (N, K) arrays\n", - "\n", - "# Per-class AUC\n", - "per_class_auc = {}\n", - "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", - " col = y_true_all[:, k]\n", - " if col.sum() > 0 and (1 - col).sum() > 0:\n", - " per_class_auc[cls] = roc_auc_score(col, y_prob_all[:, k])\n", - " else:\n", - " per_class_auc[cls] = float(\"nan\")\n", - "\n", - "print(f\"\\n Per-class ROC-AUC:\")\n", - "for cls, auc in per_class_auc.items():\n", - " bar = \"\u2588\" * int((auc if not np.isnan(auc) else 0) * 20)\n", - " tag = f\"{auc:.4f}\" if not np.isnan(auc) else \" N/A (class absent in test)\"\n", - " print(f\" {cls:<6} {tag} {bar}\")\n", - "\n", - "# \u2500\u2500 ROC curves (all classes) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "from sklearn.metrics import roc_curve\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", - "colors = [\"#e74c3c\", \"#3498db\", \"#2ecc71\", \"#f39c12\", \"#9b59b6\"]\n", - "\n", - "for k, (cls, color) in enumerate(zip(SUPERDIAG_CLASSES, colors)):\n", - " col = y_true_all[:, k]\n", - " if col.sum() > 0 and (1-col).sum() > 0:\n", - " fpr, tpr, _ = roc_curve(col, y_prob_all[:, k])\n", - " auc = per_class_auc[cls]\n", - " axes[0].plot(fpr, tpr, color=color, lw=1.8,\n", - " label=f\"{cls} (AUC={auc:.3f})\")\n", - "\n", - "axes[0].plot([0,1],[0,1],\"k--\", lw=1, alpha=0.5, label=\"Random\")\n", - "axes[0].set_title(\"SparcNet \u2014 Per-class ROC Curves\", fontweight=\"bold\")\n", - "axes[0].set_xlabel(\"False Positive Rate\")\n", - "axes[0].set_ylabel(\"True Positive Rate\")\n", - "axes[0].legend(fontsize=9)\n", - "\n", - "# Per-class F1 bar chart\n", - "per_class_f1 = {}\n", - "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", - " col = y_true_all[:, k]\n", - " pred = (y_prob_all[:, k] >= 0.5).astype(int)\n", - " per_class_f1[cls] = f1_score(col, pred, zero_division=0)\n", - "\n", - "axes[1].bar(SUPERDIAG_CLASSES, [per_class_f1[c] for c in SUPERDIAG_CLASSES],\n", - " color=colors, edgecolor=\"white\")\n", - "for i, (cls, score) in enumerate(per_class_f1.items()):\n", - " axes[1].text(i, score + 0.01, f\"{score:.3f}\", ha=\"center\", fontsize=9)\n", - "axes[1].set_ylim(0, 1.15)\n", - "axes[1].set_title(\"SparcNet \u2014 Per-class F1 Score\", fontweight=\"bold\")\n", - "axes[1].set_ylabel(\"F1 Score\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "8b2bfa0c", - "metadata": {}, - "source": [ - "\n", - "The core scientific contribution of this CS-598 project is the **ablation study**: running the same pipeline with two architectures and comparing them systematically. This turns \"I ran some experiments\" into a reproducible scientific claim.\n", - "\n", - "### Ablation study design\n", - "\n", - "| Setting | Value |\n", - "|---|---|\n", - "| Dataset | PTB-XL / CinC 2020 superdiagnostic (5 classes, multi-label) |\n", - "| Architectures compared | **SparcNet** vs **BiLSTMECG** |\n", - "| Primary metric | Macro ROC-AUC (threshold-independent) |\n", - "| Secondary metric | Macro F1 @ threshold=0.5 |\n", - "| Signal format | Full 10-second recording, decimated 500\u2192100 Hz \u2192 `(12, 1000)` |\n", - "| No windowing | 1 sample per recording (no sliding-window overlap) |\n", - "| Samples total | ~21,666 (21,837 recordings \u2212 171 with no mappable label) |\n", - "| Split | Patient-level random 80/10/10 (seed=42) |\n", - "| Training epochs | 5 (demo budget; recommended: 30\u201350 for convergence) |\n", - "| Batch size | 32 |\n", - "\n", - "> For a full paper-quality ablation, run with **5 different seeds** and report mean \u00b1 std, then apply a Welch's t-test with Benjamini-Hochberg correction across all five seeds." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "a8a558a0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - " Training BiLSTMECG [3 epochs, N=1600 samples]\n", - " Variant: lstm_d1_h64 (n_layers=1, hidden=64, AdaptiveAvgPool1d)\n", - "============================================================\n", - "BiLSTMECG(\n", - " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", - " (pool): AdaptiveAvgPool1d(output_size=1)\n", - " (fc): Linear(in_features=128, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:08<00:00, 6.19it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.5518\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 16.78it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.4503\n", - "f1_macro: 0.2900\n", - "loss: 0.5602\n", - "New best roc_auc_macro score (0.4503) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.62it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5512\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 19.24it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.4555\n", - "f1_macro: 0.3915\n", - "loss: 0.5574\n", - "New best roc_auc_macro score (0.4555) at epoch-1, step-100\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.42it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5511\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 19.03it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.4515\n", - "f1_macro: 0.3915\n", - "loss: 0.5597\n", - "Loaded best model\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 16.73it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " BiLSTMECG test ROC-AUC (macro) : 0.5065\n", - " BiLSTMECG test F1 (macro) : 0.3864\n", - " BiLSTMECG test Loss : 0.5677\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# \u2500\u2500 STEP 12a: Train BiLSTMECG with PyHealth Trainer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# Variant: lstm_d1_h64 (paper's reported best config, AdaptiveAvgPool1d).\n", - "# TRAIN_EPOCHS defined in SparcNet training cell above.\n", - "\n", - "print(\"=\" * 60)\n", - "print(f\" Training BiLSTMECG [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", - "print(\" Variant: lstm_d1_h64 (n_layers=1, hidden=64, AdaptiveAvgPool1d)\")\n", - "print(\"=\" * 60)\n", - "\n", - "trainer_bilstm = Trainer(\n", - " model = bilstm,\n", - " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", - " enable_logging = True,\n", - " output_path = \"./output/ptbxl\",\n", - " exp_name = \"bilstm_superdiag_5class\",\n", - ")\n", - "\n", - "trainer_bilstm.train(\n", - " train_dataloader = train_loader,\n", - " val_dataloader = val_loader,\n", - " epochs = TRAIN_EPOCHS,\n", - " optimizer_params = {\"lr\": 1e-3},\n", - " weight_decay = 1e-4,\n", - " monitor = \"roc_auc_macro\",\n", - " monitor_criterion = \"max\",\n", - " load_best_model_at_last = True,\n", - ")\n", - "\n", - "bilstm_scores = trainer_bilstm.evaluate(test_loader)\n", - "print(f\"\\n BiLSTMECG test ROC-AUC (macro) : {bilstm_scores['roc_auc_macro']:.4f}\")\n", - "print(f\" BiLSTMECG test F1 (macro) : {bilstm_scores['f1_macro']:.4f}\")\n", - "print(f\" BiLSTMECG test Loss : {bilstm_scores['loss']:.4f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ae628529", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAHvCAYAAACFRmzmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACSjklEQVR4nO3dB5gT1dfH8QNL71WQJipNkKKoNMGGoiKCFQEBUbGLAhZAmo1iQVABC4INEbEhiigiWFEEwQoq0qV3pJe8z+/6Tv6TbLKbXXaz7ft5noGUyeRmMsnenDn33FyBQCBgAAAAAAAAQBzljueTAQAAAAAAAEJQCgAAAAAAAHFHUAoAAAAAAABxR1AKAAAAAAAAcUdQCgAAAAAAAHFHUAoAAAAAAABxR1AKAAAAAAAAcUdQCgAAAAAAAHFHUAoAAAAAAABxR1AKAJBpnH322ZYrVy63rFixItn1q1atGlw/PagN3vbVNiQ2ePDg4D56+eWXM7o5yGF0zHnHn45FAACQtRCUAgCku1tuuSX4w1HLsGHDLDP9qNWPWS3bt2+3zGzbtm3Wu3dvq169uuXPn9+KFi3qAnMXXHCB9evXz3bv3h1cV6/Fe13ZMVi0Zs0a6969u3v9+fLls+LFi1u1atWsTZs29tBDD1lWDq5oGTNmTNTgX58+fVL9PCNHjgweF5mRP9DsLQULFrQTTjjBunTpYosXL45pO9ddd12KglWvv/66nXnmmVasWDH32Tr22GPttNNOs5tuusm+++67iO9RUosXxPa3Q4u2F+6dd94JWad8+fIRA+PRlvfffz/i5+O+++6z+vXru9dUuHBhO+mkk6xr1642a9asROvv27fPnnvuOTv//PPtmGOOcZ+pcuXK2SmnnOK+vz/55BMLBAIx7XsAAFIiT4rWBgAghQ4ePGhvv/12yG1vvvnmUf2wTkv6ofnFF18Ef0CWKFEieJ9+mH711VfusoIeGWnv3r3uR/Pvv/8evO3AgQP277//2sqVK23mzJl22223uR+fXlDqwQcfdJfPOuss99qyi/Xr19sZZ5xh69atCznOdu7caX///bd9/PHHNnDgQMvKHnvsMRd0y5s3b5puV0EpHS+SWQNTkQImy5cvd4sCMIsWLXJBKrn44ouDn9EqVaqkavv6nITvCx1jWhYsWOC227hx4zR4Jf999z311FPBz6m8+OKLlpYU5FLwyR+kliVLlrhl6tSpIQH4P//809q2bevu89u4caNbtL+ff/5527VrlxUpUiRN2woAAEEpAEC6UrBky5YtIbf99NNP7gdQrVq1LDNTxoQCQZmBMjm8gNSpp57qsiDKlCljq1atsoULFyYK/GVnzzzzTDAgdd5559ntt9/ufiwrq2TevHkRM0fiTQHD3LlzW548qetqKXD02muv2fXXX2851dNPP+0ydfRe33333bZ27VoXGHn11VeDQSRl9WhJLQV1hw4d6i4rI+vhhx+2Bg0a2NatW+2vv/6yadOmBYcH+wNgouDnkCFD3GU9RselJ1oQW+2fPHly8H31Asqx8j+/p3bt2sHLc+fOtQ4dOrggrSh4q89H5cqV3f778MMPQ55PwalWrVoFh0uXLl3aevToYY0aNXLHrwJWH330kcuUAgAgXQQAAEhHnTt31pgPt1xzzTXBy4MGDUq07llnnRW8/7fffgv06NEjULZs2UChQoUCrVu3DixdujRk/eOOOy64vufff/8N3HLLLYGGDRsGjjnmmEDevHkDxYoVCzRu3Dgwbty44HqzZ88OPjbSsnz5crd419U2vx07dgT69esXqFWrVqBAgQKBIkWKBM4444zAc889Fzhy5EjIut421N4///wz0KZNm0DhwoUDJUuWDNx8882BvXv3Jrsf9Zq87XzwwQeJ7j9w4EDg4MGD7nLXrl2jvi7vdfjX0b7wTJgwIep7NHny5EDt2rUD+fPnD9SpU8dd1zre+nrs4cOHA1WqVHHX9b7t2rUrZBsNGjRw9yUkJAQ2bNjgbgvfRnIuvPDC4Po///xzovt3794dct3/Wj/99NNA//79AxUqVHDvW/PmzQMLFiwIWf+9995z71HVqlXd+6pjSK/puuuuc8dEtG1Pnz490KtXr0D58uUDuXLlCq576NChwOjRo90xqGNRz1utWrXATTfdFHG/e0v16tXdY8P30f333x/Sho0bNwZ69uzptpkvX75AiRIlAhdffHFg7ty5SW7fv0Tz5JNPBtcZMWJEyH0TJ04M3nfvvfe62zZv3uyOae0v7TftP70OffbnzJkTSI7/M+0/Lu+5557g7dp+cser/32J9F3j+e6774LrXX755RHXCT+eIj13+PdDpHYULVrU/d+kSZPg/QMGDAi5T0u5cuWC9/u/g2Lptmvb3rq6rO+FcL///nvw8gMPPBBcv3Tp0oFly5ZF3K6+jyNtCwCAo0VNKQBAug678bJWypYt64YOeZkjGsaSFJ3tV6bEpk2bbM+ePe5svYahhWddRcpEUG0UDbvR0BNvWJfqwtx4441pUm9ItZ2USaAsCWV86XUq40JZOqq/0rFjx6iPa9Kkicu+0NAaXdewmEceeSTZ51T9KM/w4cNdtoP2i0fDvFKblROLKVOm2DXXXOOytfbv32+//fabtW/f3t57772Q9ZRd0a1bN3dZ7fNnLa1evdoNBfIynFKb4eLfF/3797evv/7aZSZ5ChUqFPWxd955p9vfyhrR+6bMk3POOcdlhHhmzJjh3iNlj+h91TGkjDQN9dQwLh1Xkdxxxx02YsQIN+zLq7+jx7Zu3dplq+gY1LGo5126dKm98MILEbej7CDtR2XqKKsmKWqXMuc0JEzb1H5Q9sv06dOtRYsW9sEHH9jR0OdQbZHwbDz/9Wuvvdb9f/XVV7tjWu3Sa9f+0+vQ5z0lGUF+GzZsCA6xlZNPPtnSiv9Y+uyzz1zbVY/JL6njKSX0+fGymfQ5Onz4sI0fPz64n4+WPl/atkcZYJGGf6q2lGfSpEnBy/fcc48df/zxEbetbKy0HkoKAIAQlAIApBsNFVGQSNq1a+cK53oFgP/44w837CwaBQ0mTJjggiFe/Zh//vknOFwmGv2AVODprbfesk8//dRmz57tfhCrOLg8/vjj7oe7fvgrIKFhNx49l27TonpS0aiouFd/pW7duvbuu+/auHHjrGTJku42PV+kYIICEgrOqeaLhgl59EM4OS1btgxe/uabb1xxcxUwVjFm1cTZvHlz8P4HHnjAvRaPXqP3uvxDjGKlH889e/YMBlr041pBQt32888/J1pfQSlvyNPEiRODt/sDJEfzI9y/L7TN5s2bu+CChlo++eSTiWrphP9wHzVqlAuWad9570vfvn2D62jf6j1RYGrOnDkuSKUC816ARO91JMuWLXNDn7S+Hq82KbDqDX3Ssan3XferjtDpp58ecTs1atSwq666yl3W8Z5UgWnVEfOCKCoErm2PHTvWDWdUUEjDxLQ/vKFn/iLa3jERaUiYR5+Dc889111WwEOfS9E29VzeZ6BevXrus67Pm+jzpfdGQ9wUJL7iiitC6ijFQsFCr/D3Dz/8EHzvb7jhBksr+l7walHpOFBQWUPdtOg49gd5jpaCh9ovomNIgUN9pymYHGvNt0iFzv3Doj0JCQnWtGnTJLelgKGOWY/3PouGTCrY618UaAQAIM0dda4VAABRXHHFFcGhIZ988om7TcPbvNvuu+++qMP3XnzxxeDtM2fODN5+wgknJDl8T6ZNmxY4//zzA2XKlHHDxMKHKv30008RnzN8aFak4XsanqZhd97tv/zyS3D9Z555Jnh727Ztg7f7n3vhwoXB2zX0z7t9+/btye5PDdvSsLBIw680zNE/vDGpoYcpHb73/fffB2/TsDdvmKA0a9Ys4tA77X/dlidPnuAwvVatWrnbNPwvltcbjYa0derUKepQtBNPPDGwdevWiK9Vw5U8Gkrp3a4hdd7wpC1btrhheDVr1gwULFgw0fYvu+yyiNvu2LFjorbWr18/eP/zzz8f9TX593v79u3dsETvvX777bcjDt9TO711NGTwq6++Ci5qo7e+Hp/cZyYp/rY9/fTT7jYN3fRuGzZsmLttz549gdy5c7vb9P5rmJj/WImFv32RFg1L1OtOq+F78sUXX7ihvtGec9SoUWkyfG/s2LFuGKcu67vJ+zxceumlIZ/XpIbvRVo8r7/+esRtRLNmzZqQ7fzxxx8Rv8ti3Y8AAKQGmVIAgHShrAll00ipUqWCZ+Evv/xydxZflE0ULQtEw+M8Ktbr0ZCqpDJHlLXUpk0bN1RI2UPK8gnnn3kqpTScUMPuvMwX/1Aifzv9w8E8ymzyZ2apqHBK2jRs2DCXmTRgwAC3f/zD9dQu3Z4e/NkUar//ef2v2c/LZjl06JB7n5WVoawjUdbO0cxmqONHhd81HE4ZTN5wN49m4FNGXHLHlbJkvOw2DalTFpCOF2XjaBiesvk062G4aO+Vjrtw/uPgkksuifk1KvtIM6LJo48+GnEdDdfzPgsaMqiMMW/xD6tcvHixHQ1lOakIuH/Inve/MnW84apax8uA0+dPQ770GdH7o9kQd+zYkaLnVZaZsrj0PXL++ee725RdlJaZUqJhjnqvlb2kfe7/XIpmCj2a7wy/Tp06uX2i7yYvg06zLMbKn90WnuXm/0xp+16x82jCP4PhwxYBAIgHglIAgHSh4VH6oS+ayUr1SPQDVnWEvECRZp6KZXiMf4hKcp599tngZQ2J0RA+/XDzftTKkSNHUvhqYmtXcu30AiAef3AnqUCbn4JgGp6ogIx+eKpWkefHH3+MseWhbfUH7vzDAFO6HT8N11QwUhRA0lAv1aKSaDW3UkoBpieeeMK9bgWUFPBM6b4Ib7+GRnrDSjV07ZVXXrEvv/wypPZOtONHw1PTkuplidqjYExqJTWcMRYahnjppZe6yxrGtXz58mB7FNDRUDePhtxq6KLWP/HEE92xpTpiGraoGmQpocCchmQqiKmZCD0aFuh9t6SVEiVKuGCXvrdUM0yBMC8Qp8CkN1z3aCkQdOWVVwavV6xY0S666KKYH6/9Eb546tevH7ys/a7viKRoiKc3NFq+/fbbkPpo+k66//77Y24bAACpQVAKAJAu/D/ikxKt4LmKhnu+//774OWqVasmGfxRjRaP6icpGKXaKv7b/fwZNrEEq1QTSj9gvR/7KvgdqZ2qC5SWtD/CA0b6gXvTTTdFDC4l97r8WRLKsvF4dYL8/D9cFWDwP4//Nfvlz58/WPxabVeRey/AocLfR0NBImVehQeEunbtGrweKUPOa4s/00gBUylQoIBVqFAh5DhR8Ex1mpR5FItIx6X/OPAyB2PVsGFDu/DCC91lr6aSX7Vq1YLPqQCQstIUSPAvqp/mL+6f0uPdn+HjPebmm28OBrq899gfaNUxOXXqVLd/lVXo1TZSgDi1ATJ/0FZtSKvMJb3/4cEb7SMFwmrVqpXs8ZQamnDBHzj3MkePloKDmkjBozppkbKl/Jlz/kCh6rF5NcMAAIiX9JumBwCQY2mGPG+mLQUhwouT64eyVzhaBbkVsPD/WPZ+UOkHrooj+4tQe0OaojnuuOOCQ6Y0ZKhVq1Yuy0KzXSWXvaTi0/oxqgwJrwh2OLVThb5VvNn7sT5o0CD341v/e9JiNi0/ZYdohrXLLrvMzVyn16nhUF6wR/yFs/2v65dffnEZIGXKlHFFnbUooOHPyNGPfGVKzJo1K2JwRBkdCtjoR6sCNQpGaF1lFkWjzBMNwRJvPWVQeRkonsGDB7ti7V6mTXJFnzVrnQI8KgauGRkVTFIBcv9xFq2IuPahAljaB/5hccpWUTaf9qtHBemViaL3VkO4UkP7yStArcLwysJR27Qv9TqSyxTUexMpUCjKRFO7lbWkIYvKTtI+12dOWYjKsNJwVj2HgrnecaFMJy9oq/dWAUplJSVFwTENa/N/thV49Gf9eMExDfdT1o7eF71e7/kUWFK2XKwFz3Xc6jtABci940gUFFZwOFaaVS9SZpWGwyoopUCOZlXUZ0v7QcfB559/HpwpUq9ThdzTioKcmhlPbfIHqGKhTLVw3mfaCyzpM6FglD5zei5lU1aqVMkVL1fxfm9oszfjniYjUBFzfQfo2OzVq5cbcqn2zZ8/P41eNQAAUaSqEhUAAEnwFzNXsfNIGjRoEFzns88+S1R0vHr16okK7R577LGBjRs3Jlm0ecqUKYkepyLWDRs2jFjYO1JBX203qWLhKrTsL1IevlxzzTWBI0eOBNcP324sRdbDqUB3UsWOixQpElJ0XfyvObxY8ebNm91jwu8/6aSTIhY2njRpUsTnrVatWsRC557TTjstZP3p06cnWsdfxDvSNsIlVeTcK/q9bt26iMWm69WrF3HfLV68OFhEPdI6/oLu/mMhWsF4j4qnt2zZMtki1eGFzv3OPvvskMd4hc5l5cqVgUqVKiW5P/zHVu/evRPdH61Id7hbb7015HGXX355onUiTSzgLSrsfbSFzrU8+eSTKSp0ntS+/+uvv5Jdb/DgwWlW6Dyaoyl0Hl6AXIXtCxcuHHX94sWLh6z/22+/uQkkknueRx55JNn3DwCAlGL4HgAgXYfuebVokioKHWkInzKoNAxI2RnKrFFGiIZtJZchocwN1bRREWsNydKZf2Wa+AuS+2kokuqmKNMgPFsrGmWoaMiPMrhq1qzpMimU/aHnGjt2rL3xxhspqoMVC01Vr8wW7TcNCVM2jDI61O7OnTu74V3hr1HvgzJcwmtZifarsqeUAZIvXz6X4TJ69Gi77777Ij6/ssO0vZNOOsmtr9c9fvz44LCuaPxFqZWp5a/tlVrKSHvsscfsggsucO3Wvvdew6233uqyO8qXLx/xscokUWaWMr/0vikTavbs2cGhWhpKpSwsZeQpg0jH21133eWKYKeG3qOPP/7YZfqoKLzq+Oi4VKZarAWukypgr/dfGVH33nuvew3ato4NXVZGmzLs/DWftO/0uVIWU0qP0fCheuHXRdlqyk5UZo72rxYdK2qfPtOpoc+ljlcVoH/rrbdcJk9aUWacssn0PaAi/qp5p+wsZWOdffbZLovInwGZFShTTTWwtM+V+aVjTt+hOuY0JNUrUu9RQXpNoKAsQmVW6ftNnwNNzKCMN+0bHcP+jFUAANJKLkWm0mxrAAAAPhoW5A2JU8BozJgxcW+DhgOqYLkoAKVgAwAAADIeNaUAAECaU+0gFSP31wJS5g4AAADgISgFAADSnIb8eNlJomF7KiYNAAAAeKgpBQAA0o3qMmnaedXmAQAAAPyoKQUAAAAAAIC4I1MKAAAAAAAAcUdQCgAAAAAAAHFHUAoAEJNcuXK5pWrVqjE/5uWXXw4+bvDgwZaZ23o0VqxYEXzOs88+O3i7XrN3u/YFkF1F+6zr8+Ddrs8J0v876vbbb3fbrlmzpmVElY5o34fZzTfffBN8nT/88ENGNwcAsiyCUgCQSv6Ag39RYedmzZrZSy+9lOofBHPmzEnyR4v/ua+77jrLSGqLlpEjR2ZoO5D5Pwf+AEVyixfEi3RfoUKF3A9u/fhes2ZNsm288847g49t165dovs7deoUvL9Lly7B2/3PSUAFKfH+++8HvxvjeeysWrXKxo0b5y736NHDHbse/S2J9nmLVwA/O9H32+mnn+4uDxw4MKObAwBZVp6MbgAAZDc7d+60b7/91i06kzp+/HjLzh588EH3/3HHHWd33323ZQZfffWV+79AgQIZ2o7rr7/eWrZs6S7XqFHDcpL0/Bzs3bvX/vzzT7dMnTrVfv31VytRokTU9YcMGeKCBApgaf333nvPLrvsMnffjBkz7I033nCXy5QpYyNGjEizdsLsmWeesR07drjLxx57rOUUOt5eeeWVYDA2POiTXt9RTz/9tB04cMDy5ctnnTt3TtNtI7Ebb7zRZUnpe0TfQyeffHJGNwkAshyCUgCQBi666CLr16+f7du3zyZPnhw8Uz1hwgS77bbb7LTTTsvoJuYoZ555ZkY3walSpYpbcorkPgf+AIWXwbRo0SJ3WY/T4z2RgnhTpkyx8uXL299//2133HGH/fvvv/bPP/+4AEBSGYNFixa1Z599Npglpec977zzLCEhwW699dbgegpIKTCFxHbv3m2FCxdO8ePq1q2bLu3J6tLjO+rQoUP2+uuvu8vnn3++FStWLMnPqV9GB/CzKn2n6DvkyJEjLrvziSeeyOgmAUCWw/A9AEgDxxxzjPuRoayYF154wY4//viQM+KzZs0KDpPo2rVryGN/+umn4H1t2rQ56rboh7qGjOiMbcGCBd0PE52p//jjjxOt27t3b2vatKnLYMifP78VKVLETj31VNex1g+cWIZteVauXJnsUBAFFerVq+eeS0GHt956K6bX5B92smHDBjfcSpkxGiKmyxs3bgxZP1I7wmve6MdbnTp13I+x2rVrB7NlUrsvk9pH4TWl/K9n/fr1LqOhZMmSLnjSvn1727p1a6JtKcNHx5fW0/7T8DVlqSlrKKt8DhSg0P3eovfPU7169ZD7tK1wCu7qPn2GLrzwwuDt2ofJadu2rV1xxRXusgJZ+lGuITfe0Cr9iE/rzBJtu2PHjlahQgXLmzevO2Z1rHXr1s1+/vnn4HrRPjeR6jGF1+tRlsZZZ53lhjTqeQYMGJDos6vhkwoMariRjmEdy/Xr17dRo0a5H9N+/mNTQ8G0z/Q++TNAPv/8czdsSZ+dE0880UaPHh11H0SrKZWS7x618aGHHrJKlSq513nOOee4YGas+0fr63EKaPbv3z/Ra1Zm0fDhw61BgwYu8KZ1tX+GDRvm7gv/vtaxpONT72np0qXd42655Ra3v7zn97KkRM/vtUlDs5N6zw8fPmxjxoyxJk2auP2u90qfjZtvvtmSo6xEfT/KBRdckOzn1L+k5MTJd999Z1dddZU73pSRpf168cUXBwPM0SiTSN/X+gyUKlXK7T+1pXXr1vbll1+GrKv36NFHHw1+9+pYU4Bf62pIsEfff/fee6/bRzqO9P7pe+fyyy93GZF+mzZtsl69egXX1XeptqfXE+755593+0THpdatWLGi+1577LHHEu1L/U2T8OcDAMQoAABIlUGDBqlQjlu6du0acl/9+vWD9w0bNixw5MiRwPHHH++uFy1aNLBnz57gug899FBw3TfeeMPdNnv27OBtxx13XMzPvX379kDdunWD94Uvo0ePDtlO/vz5o67brVu3kHXD2+NvQ/jirTNhwoTgbbVq1Uq0Xu7cuQNLlixJdl9re95jatasmWg79erVC+zbty9qW8PbEmkb/v2f0n25fPny4O1nnXVWxPdJzx/p9ZxwwgmJtt2pU6eQ1z9gwICo7WjevHlg//79gazwOQinfRVp//j5X6v2syxbtixkH06bNi2mtq5duzZQvHjx4LGXkJDgLhcqVCjw999/x/TcsTp48GCgRo0aUd+3F198MdHzhH/W/fvHe37/sVapUqVA4cKFE2375ptvDtlOly5dorajffv2IetGOza9tn3zzTeBfPnyRfwMepd1TCT1GlL63dOjR49E6+h9rFq1apL759hjjw0ULFgwyX2v740WLVpEbYvu8z5fmzdvDpQtWzbqujNnzgx5/kiLvtujvecHDhwItGrVKupjkzNkyJDgul999VWi+733tmTJkoFixYoFChQoEKhTp07g0Ucfjfk7ZPz48cHPTfjifYajfR9OmjQp6mvT5/Hzzz+P+HcxfGnWrFlwveuvvz7qev7v0ZUrV7rPS6T18ubNG5g6dWpw3VdffTXqNitWrJhon/jbsG7dupj2IwDgf8iUAoA0tH//fnvttddCsiCUHaIz4sqOkF27dtkHH3wQvN+7rLPzl156aaJt+jOQvMWr4xTugQcesF9++cVd1pnrjz76yF599VV3Jlt69uxpq1evDll/0qRJrh6GzuC/++671qhRI3efMnuSKiKtekleXRTRc+i6lrfffjvR+kuWLLEbbrjBPvzwQzd0yjsb7g3xitXBgwfd0DC1zxtqpf2tzJxY/fHHH3bXXXe5/XPttdcGb9dZdG0/NfsytXSmX1lbyo5Q1oG8+eabwWFuyvR4+OGH3WVllShLQO+XzvCL9vdTTz1lWeFzcLSUAaHj/4QTTnCfC1F2k96fWGj/KfvFO/aUleJltGmbaUnHu2peiTIs9J7p2NcQRg2fUvbF0dLnU9lP06ZNc8eIhiN6WR7evtdnUcetKLtOn3et37hxY3ebPktaIlHWjYY0fvrpp8HhXspw8rKH9Lq85/7tt99S1PZYv3v0WdU+k9y5c7vsNj3nGWeckWwB8XXr1rnsK2UZqui3R/vHowkavCydypUru4xJtcsbdqv7vM/X3LlzXbaNdOjQwWbOnOmGjiq7S9lq2v86xvSZ9A9FVZ0n77vxlFNOidperffJJ58E/x5ov2r/vPjii8GC2klZvHhx8HK1atWirrdt2zZX803DbPW+6b3Q94n3eYhGGYYaquatp6Fryg7SMda9e/fg91c0Ov6efPJJt8+UbacM4rFjx7rPgj6PQ4cODa6r90yUXajvx88++8wdx8pI89cm89ZTTUO1Q8eqviM1YYEyoTwaPuwdU7pP+1XPrUwofefr75mGqPq3mSdPHnvuuedcOydOnOiOfX/2Z6R9/fvvvye5DwAAEfgCVACAFEgqU8hbTjvttMChQ4fc+qtWrXJng3V7mzZtgpkbuXLlcrddc801wW37M6WSW7zslMOHD7sz4LpNmQyfffaZO1uu5bbbbguu/8QTTwSf5+uvvw60bds2UL58+UCePHkSbdt/9jjSmf2kbg/PTlLWjOe7774L3t6uXbtk97U/e0PZCB5lPHi3n3vuuUm2yd8W/5l2vT9VqlQJ3vfll1+meF8eTabUe++9F7z9wgsvDN6+aNEid9tdd90VvK1fv37Bdig7yLv95JNPTnL/KUvAe1xKlw0bNqTp5+BoMqXCF312lAW0d+/e4PqRXoM/i04ZcP4sHWV9RHuNR5MppQxA77GdO3d2mVg6rpJ6npRmSinDS6/Ho8wQ7z5lmog+395tTz/9dHCf+D87l1xyScRj84UXXghpj/aTd5/24ZYtWyI+dyyZUrF+9wwfPjx42xVXXBF8/NatW0OyoCLtH312169f727Xvtf+0u0lSpQIbsef4eXPuPN/vrzvrhkzZgRvu++++9x3urJgI9H3cnh2VHLvuT+z8Pnnnw+k1EUXXRR8vP+Y95x99tnuO+Ttt98OTJ8+PXDnnXcG//5oee2115Lc/lNPPRVct2nTplHXi/Z9qO+AkSNHBk4//XSXMex/bi36zvU0btw4mJk0d+7cwO7duyM+l44f7z1auHBhxNet49R7Lq3v/2647LLLgs+v/SL6W+x9vvTdv2PHjiT3y9ixY4PbmDx5cpLrAgASo9A5AKQDnTG++uqr3Vl4L3tBZ+FV50NnaLVs2bLFnfH/7/fJf2feI1Fmjmox+WkmM9WI8du8ebM7Ay7KZPBmfYt2Nn3evHmu1omXGRTJ9u3bLa0ok8CjOiypfQ4vm0KULeFZtmxZqrah96dhw4auHoy3HZ3RT8m+TM/94mXbeLPIaYmUlZMUHS/RsuuSo+MsqSLiKf0cHA2v0LmyVR555BH78ccfXfaE6tN42SzNmzdP9Ljly5cHa/co40eZXB5lffTp0yfNZ8lU3Rq1RdkxyhrT4tVyUr0bZe4cbbZUrVq1Qupy6fOgjA7/58F//PizhWI5jsNr3Pk/Y6olpf0e6bmTk5LvHv9z+j+3yoLR61+4cGHUbej+cuXKBbOs9Jg9e/aEfOf490+07xZvHb2fel//+usvV1tIi+rAKRtLtZKUCarnSS1/Wy655BI7Gt7fFb/Zs2eHXFc2lzIyvUw61crzZ44m1T4vUzMllImqbLBo/O+L9qVqPSk7S/W1vAxJZdkqY8mbCEHrqfaUan0pC03fM7pPNedUa0pZVUuXLg3uD9Wfi/Qd4f8cKKtZ2YM6VrzvftUz03e1ZpgNr78VaV8DAGLH8D0ASAPq3OvH59dff+06x+pc60eoP8jgdaBFP8ZU5NsbuqcfS/7CzX764RpelPZoZnTzhihoWIL3o1A/gKZPn+5eg4Y2eMILAh8N/1AKDYtIiw69v9D60Ujtdrx9mdH7RYWh/YGWzP45SC2v0Plll13mhjt6og0/C6cfuTruRcEEb98r8Bb+g/1oKTihz5SGK+mzrc+shmqqDffdd58bPhoufPiUAs0ZeRx7AZ20fu7Ufvek9PX5P1vhn6/kRHouDan75ptvXNH1c8891wVINRz7iy++sJtuuilREex4888c6QXVk+MPvnlDE9ODgvveEGu9DxpGq8+c3nev3f7vvBtvvNEFyTQ8V8XOFeDWrJvahoJDXgBLQxw13FKF13UyQe+bgksKUuskUHITdkT6HOhxep81JFGBLr3vGvqnoKueO/wEiH9fM3snAKQcQSkASAPebEaq76KZeJQREYlqRnmdVtW9UK0K0QxXydXjSI626/0IU50M/VhSJ9+/6Eevl2GlM9Ae1fJQQEGvwZu9KaU/3tIygJVcloXn+++/D15OSU0g/za0T+bPnx+ynZTuy/TkZQSIni+8HVr0YyqprBvVTIr0uFiWlGRJxfo5SAv+H7D+2QojvQZlSSkIoh+Z3nGqjLPHH388+DjNbqYaO2nZPh07yg7Rj2vVwNIskV5NGtVQ8njZTsqe9II1qpeUXAac6i2pNlBSnwf/8aMgQKT9ox/7sQRm/PV09MPc/2Pc/9zJScl3jzKyPKqv5tFzJ7d/YuHfP9G+W7x1tK/Kli3rZjjUd7dqVmk/6H0Of0/9GVOxfjf626Iadil10kknBS8rO8hP1yNlpfpfZ3JBSH/7FEhMCR3b3udL2YL333+/mx1Rx2mk2Ua1rxXMVRaXavtpJlRlKXnZTppp0HPNNde4kzw6HvRdfeWVVwZn+1N2l2o+eceyjicFqsI/AwqaKdjoPbeysxQAUzamtqngsih7SpnOfv59rZkFAQApw/A9AIgjBZ505ldncRcsWBC8PdrQvZTQjyBtRxkk6sDrbK+G6yjAorO86qDrR5OGKenHgArD+n8Ydu3a1f149grtxkrBG/2oWLt2rTuTrO3qx42GuaQHBQ/UXv3AUYFej6Zpj5UyeRQsOP/8811RcW/ontqtAtAp3ZfpqWPHjjZq1KhgcXXtawV89ANTwQQV9tU+T+vhZ5mRgofa//qBq+F7kX4sR6MsFr1v3jAtFT7W+6xjVsEaDclS1oWGAkUyfPjwkKFyomGfytCIFnjR0B8NX9QPVR1bGkboZaP4M9v0o1nfB8qk0vvdokULd+wlV3hawcj27dvbHXfc4TLTdCyHfx40rMwr3KzvHn1m9NlUO/SaFfxQUGjQoEHJ7kO9Bu07BTL0+VMwQJ+L8OdOTkq+e/Q6FMBQoOCdd95x75GGy+kzof11tLS/vaLwt99+uwtAKIChIZ3h388KhOj16iSC9qG+D/RYBSrC31N/lpYKdWtYmRYF36LR0DntS++zriCmCpzrWFKARIXWk6JgsEfBFP8wNe87T9loGjqpILbee7Ut1u9QHevaL3qdyiTSftD2FHRT0Xc9v463aMdOgQIF3HGjIJNej27T+xkpaKfAkrIZ9Ro0dE6BJP/JA29f6zmVzaSMr4oVK7r3z19sXOtpmKmOcQXS9J2pk0PKWtb2FSzWEFB9n2v/KoCt91gBR/190LB7ZXb5J/UIz0r1hpAqwOZNhAEASIEIdaYAADHwF3j2io3H4tdffw0p7qppy8MLIPsLnUcqIB7tubdt2xaoW7duksWhvaK733//faJCs7repEmTiMWno7VHxYfDn8Nrk7+4uL/4cbRCuNH4iy/7CxP7C337i11Haqu/LdH2kb/Qb0r25dEUOo+lOPKAAQOSbEdKjr/M8jlIi0Ln3jE7ZcqUJJ/nzz//DBQoUMCtr6LaP/30U/C+v/76K1gwW1PD//zzzzE/d1Kvd/Xq1Uk+9uabbw6uq6LW4fcXKVIkZAr7SIW8dRwVK1Ys0WNvvPHGkLaoGHxSbfF/NqMdmx5NBKD9FL6N6tWrx1zoPKXfPT169Ej0fHrd/rZG2j/h3y2RXpsKYzdv3jzqvmnRokVg//79bl0Vxk5qPw4dOjRioXT/ktR31IEDBwItW7aMuv3kHDx4MFj421+8Pvz7L9Jy1VVXRS3a7qcC+d6EHeGL955Few9uv/32iMfNMccck+g1nnfeeVHbWq5cuWCB/xNPPDHqerVr1w5OsKDJHvyfp0iLdwzdcMMNUdfRd4UmLfAX//f2xz333JPs/gMAJMbwPQCIszp16oQU1FUmxdEUx/XT9Nk626uzzxoioeFTqoehs/o686zaG95U8DqzrOm869at685gq10qJK2soJR49tln3WvQsJZ40LAZZXwoa0VnupWtoenC9RpipULTqkOk16zsNdUiUe0jf5HflOzL9KZhJR9++KEbzqL6THnz5nVZAcq6UG2W1BYxz6qUcaIsCxXiVoaGN1wnGv/QPBVJVqaZP0tJwxtFQ+dUGygthqIqO0PZR6pBo2LLes90DOm5leX1zDPPhNTP6du3rxv+qHVUr0iZGf6ha5Eoq0P1jJStp8cpS0OF3DXVvd8rr7zihkGpLfrc6JhXjSsVjVbhaWWNxUqZK8o4UbaStqOsJ2WRqf2xSul3z4gRI9x7VKFCBbe+2qDsNn82kj6bqaGMIR1D+hx5Q071HGqbsriUiegNrVZGnrK29LnX8acMGg3dUzbT6NGj3X0e1cp64okn3HsYay0rHSPKGNN7on2kbastOkY19DQ5eh7vO0yvSVlD/vYoQ1fHlrJ/9JqKFSvmMo3GjRvnvg9jqdmlY1XHpr5DvX2g41aZSA0aNEjysdofGoKnz4NemzKW9H0eaZivjkllAWr/aV09j77zlImlrC8va1HHnTK8dBzqGNA+1Ofilltusc8//zw4wYKOd2U0qfi5CuBrv+rvhy4r20v1HbVfRM+h7D39XdDzaBt6je3atXOv3T9U/P333w9+X6R2QggAyOlyKTKV0Y0AgJxGQQZvuIyGwviLzSIx/cjQMAtJ7Z+tl19+2c2qJNr3XiACyEpUa8qr7aQg05w5cyy702c+PGCiIZwKNGjonALIup5Wwf2sbPXq1S6IpRpJGgJ66623ZnSTsjX97VatM294IAAg5fjrDQBxpPpEKorq1V/RWVoCUgCQdIaNMmJUx0hBF2XKKDvOq+WkWkcEpP6jbB9lM8nIkSOPanZTJE3Ho1d8P6dlqwJAWqLQOQDEkYYL+GkWJwBA0gXdNbxOS6QZ5zTMDv+joYRakL409JGgHwAcPU4rAUCcaRiK6l9o9ijN/AQAiE41s1q3bu1qCqkWkmoMacY1DYOeN2+eq7MGAACyJmpKAQAAAAAAIO7IlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAgAAAAAAQNwRlAIAAAAAAEDcEZQCAAAAAABA3BGUAhCiatWqlitXrpiWOXPmpPnzjxw50gYPHuyWWL388suJ2paQkGClSpWys88+215//fWoj122bJndeeedVqtWLStcuLBbdPmOO+5w90Vz8OBBGz9+vF1wwQV2zDHHWP78+a1KlSrWsmVLe/75523Xrl0pet379++3EiVKhLR/7dq1idbTfvHWue6660LuW7FiRcg+iOSHH36wbt262YknnmgFCxZ0++iUU06x++67zxYvXpyiNgMAgOzZjwpftm/fHlx/6tSpdu2119oJJ5wQso76ISkxd+5ca9u2retH5c2b18qUKWN16tSxjh072qRJk1K0LQBZV56MbgAAhHemVq5c6S6npEMV7siRI7Zt2zb74osv3LJ161br0aNHyDpvv/22de7c2fbt2xdy+x9//OGWl156yV577TW78sorQ+7/559/XCdqwYIFIbevXr3aLbNmzbJy5cpZu3btYm7v9OnTbceOHSHtf+utt+zuu++2tNKnTx8bPnx4yG167dpPixYtsj///NPef//9NHs+AACQNftRSZkwYYILTB0N9ZUuvPBCO3ToUPC2LVu2uOX333+3jRs3WocOHdKgtQAyO4JSABIFavxBmquuusrWr1/vLj/99NMuq8ZTt25dy2waNGhgzzzzjO3cudOeeOIJmz17drDt/qDUwoULrVOnTnbgwAF3/dJLL7Xu3bu7y+PGjXOdLe0HnQmsVq2a265ofa37448/uuvKburdu7c1btzYZTvprJ+CWSkV6Yzgm2++mWZBKe0Lf0Cqffv2bilWrJj99ddfNnHixDR5HgAAcrLs0o8KV7Ro0eBlZYarD9W0aVN74IEHQrKoYjVw4MBgQOq2226zNm3auOvKUv/8889dnyqj6MSg+nsFChTIsDYAOUoAAJJw3HHHBfRVoWX27Nkh9+3atSswaNCgQJ06dQIFChQIFC1aNHDWWWcFpk+fnmg7b7/9dqBZs2aBYsWKBfLmzRsoV66cu37fffcFjhw5EpgwYULweSItSfE/Vs/vWbBgQfD2fPnyhTymTZs2wfvOOecc1waPLus2736t63n++eeDtyckJAQWLlyYqD07d+4MrF69OsY9/N9+LFiwoNtm5cqVA02bNg0+x7Jly0LW1f727uvatWvIfcuXL4+4z7Zs2RIoUqRI8PbevXtHbMfvv/8ec5sBAED27kfFQu3wHqt+SKz0evWYUqVKRbx/9+7dEfsp6vtUqVLF9evKlCnj+mufffZZyHqzZs0KXHzxxYHSpUu7fVWpUiX3uD///DNqn+qll14KPPzww27buXPnDr5X2rfjx493fTO9P2p3vXr1AiNHjgwcPnw45tcLIDqCUgBS1Znavn17oG7dulE7P6NHjw6uO2fOHPcHPtq6Bw8eTJfO1Pz584O3V61aNXj7nj17XGfGu+/DDz9MtM1p06aFBLT27t3rbj/33HODt1933XWBtPD6668Ht9mzZ0/X0fGuDxky5KiDUq+++mrwtuLFiwd27NiRJu0GAADZtx+VnkGpsmXLBh/Xp0+fwC+//BJygjDcjBkzgifwwhf1jTzab7ly5Yq4noJK8+bNi9inOuGEE0LW9d6rLl26RN2n7du3T9G+AhAZhc4BpIrStX/55Rd3+eKLL7aPPvrIXn31VStfvry7rWfPnq6+kkybNs2lQsuQIUNcHQENTevfv7/Vrl3bFcfUNr766qvg40XXvSVWqsv09ddfuxpN9957b/D2m2++OXh56dKlwWF74g3N8/PfpnX1GPnpp5+Ctzdv3tzSgn/onupXXXHFFcFC5dpPR8vf5nr16rkhewAAIONk1n6U6nCGFznXpDFpTRPDeIYNG+aGMpYsWdKVSJg8ebKiaMH79+zZY126dLG9e/cG+19a54MPPrBevXq5SWpE+0v7TY/NnTu32z/arxpCKZqERpPE+Lft0bBBDUn03oeKFSu6oZi6LDVr1nT9Nb0XKtkgaoMWAEeHmlIAUkwdozfeeMNdzpcvn+sQaPY5BTsuv/xyGzNmjAvkqFC36i1pRhVP9erVrX79+la6dGlX0+jhhx92t2vmFW8WO8+ZZ56Z4rapYLc/WFSkSBFX6FPt8KjelF/ZsmUTbSf8Nq8Iub8YeYUKFZJtjwp1qoC4X/HixYN1JFSA/dNPP3WX1QFq0qSJ6wA2atTIvvvuO/v555/drHgnnXSSpVZK2wwAAHJmPypeVOtS/SP/pDHqryjoo0Wv/Z133nG3q5+k/pQcf/zxNnPmzODrVC0qj4JI3knHyy67LLhvzj//fBeYU20vFVHXybrwE5LNmjVLNFuz/+Tm7bffbpUqVXKXb7jhBtdHEz1G7wOA1CMoBSDFNm/e7GZsE/3x95/t8lMwRXTm6amnnnJFK72zVeo4qQOg4pbRHp8W/v33X9fhUQdQZ80kPFNo06ZNLiAUflt4IMn7XzPDyNq1a5N9fmVsdevWLeS2s846KzgNtDpcBw8edJfVEfUypLSfvA6Pzsw99NBD7rJ3v4Sf6fNf96/ntT3WNgMAgJzZj4pU6Nzfj0grOkmmyWE+/vhje++991yG1vLly4P3v/vuuy4YdcEFF4Sc3NNr9Qfe/Pzr6eSeR0E9FZjXc3nrhQelLrnkkiS3Fz6Dc/h7BCD1GL4HIN3s3r3b/X/yySe7wJD+oKuToM6NznipE9KqVSv79ttv0+w5FfA5fPiwff/991auXLlgUGf06NHBdTSbns5M+rOrkhrypnX1GNHZSc8333xz1O31D89TJ9BLlfdndvlTw/2z36hT6+e/7l/P32ZlXil9HQAAZG4Z0Y/StpVh5V/Sa5ZABYs0XG/ChAlu+JyGM9aqVSt4vzfTcVrwn6yLxOszpvY9ApB6BKUApFiZMmXcuH9veJyCHP8/cUJwUWBInQzR9Tp16tioUaNc9o+mDlaKtSiD6f333w9u28tm8u5LDW3jjDPOsOHDhwdve/TRR4NTNBcsWNCdefPo7KM/y0iXdZtHHT5vWmB/irbqDCjIE077Y82aNe6yV7vAv3hZUuvWrQteTorO1HkdM9U08KgTqkwwzyeffBK87O/UtW7d2r1PXmr8I488EvF5ONsHAED6y+z9qHhQ1lJ4+xR8u+iii4LXtQ+kRo0awds+++yzkLqgfv715s2bF7ysjPSFCxdGXC+poJV/vdmzZyd6j7T8/fffMb1eANExfA9AiqnD06FDB1fzQEERBXh09k6dLAVjfv31V5d2PX78eFcc87HHHnPBFwVHqlSp4gpS+gMoSkf3qJPmpW8rc6hhw4YhNZhSQunuAwYMcIUvN2zY4IJIN910k7tPdabUBnVUVDBUQ+dUI0Cdkpdeesnd5mVJaV2PgkzPPfec69wcOnTIvb577rnHBcH0OpSKrsePHTs2WHsgGtVL8DpkSkdv27ZtyP2qf6B1vGyvU0891c4991xXR0JDCNUpVbFNPU7D8l577bWQgumeUqVK2aBBg4K1EfR+aJ9cffXVbiijgl4TJ0502/V3bAEAQM7tR0Uzf/58W7FiRaLnVqBJNTnVPn9wKZLu3bu7PpZO9qkPVaJECVuyZEkwECenn366+1/7R8MVlR2m16brd9xxhzthqMlt1H9RH0d9n/vvv9/17bT/1PdRP+mVV15xJwJFheH9GeTJ9SOnTp3qLnfu3NkVp1dNL5V4+Ouvv1xRdL1OPQ+AoxBlVj4ASHIq423btiU5lbF//YcffjjqOpri+Ouvvw5ut3fv3onWSW564qSmMn788ceD99WoUSNw+PDh4H2TJk0KFChQIGrbdN+bb76Z6PnWrFkTOPXUU5N87e+9916y+7Zx48bB9adNm5bo/kWLFgXvr1KlSnCq5MmTJwcSEhKiPvcZZ5wR2Lt3b6Lt3X///Um2uW3btsm2GQAA5Jx+VCRdu3ZNst16zcmpWLFikts455xzgv0emT59eiB//vwR1x00aFBwvdGjRwdy5coVcb2iRYsG5s2bF1xXj/Pu0z6IpEuXLkm20//cAFKH4XsAUkVntJQVpJlNdMZJQ+IKFSrkziDpTJUye7wpczVN8c033+zSsnUGLyEhwWXv6EyXzvSpUKdHZ5uUzaQCmMmN/4+FzsR59ZWUEeSd8ZJrrrnGnY1UkVClaOs1aNFl3abaBpFmVFFRdKXPjxs3zmU46cym6iKozapppfpV5513XpLt0hlGr5C59lukIqXarzojKqtWrQrWjFCGk+pZqdipnjNPnjwu/V+ZVJoqWmdTveGGfppyWensXbt2dbPXaB2dPdX7oimUhw4dmuL9CwAAsm8/Kr2opmafPn3crMPKLFfWlF6/CpCr5IImivG3XxlJqquljCWtr36XMqSUSeafdVn9N83Op/W1j9RH0r7o0qWLe7yXfRUrZVkp0179O/WZ1E71zdTPe/rpp93zATg6uRSZOsptAAAAAAAAAClCphQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAHJeUOrLL7+0Nm3aBIvxxTIduYr4qqBv/vz5rVq1avbyyy/Hpa0AAACZBX0oAACQ1WV4UGr37t1uxgnNVhWL5cuXW+vWre2cc86xRYsW2d1332033nijm3kCAAAgp6APBQAAsrpMNfuezvK999571q5du6jr3H///fbRRx+5adz907pv377dZsyYEaeWAgAAZB70oQAAQFaUx7KYuXPnWsuWLUNua9WqlTvbF83+/fvd4jly5Iht3brVSpcu7TpxAAAA0ej83a5du9wwudy5MzzJPNXoQwEAgMzWf8pyQan169dbuXLlQm7T9Z07d9revXutYMGCiR4zdOhQe/DBB+PYSgAAkN2sXr3aKlWqZFkVfSgAAJDZ+k9ZLiiVGn379rVevXoFr+/YscOqVKnidk6xYsUytG0AACBzU9CmcuXKVrRoUctp6EMBAID07D9luaBU+fLlbcOGDSG36bo6RpHO8IlmmNESTo+hQwUAAGKR1Yer0YcCAACZrf+U5QojNGnSxGbNmhVy28yZM93tAAAAiIw+FAAAyGwyPCj177//ummJtXjTFevyqlWrgmnjXbp0Ca5/yy232LJly+y+++6zJUuW2JgxY+ytt96ynj17ZthrAAAAiDf6UAAAIKvL8OF78+fPt3POOSd43atb0LVrV3v55Zdt3bp1wc6VHH/88W46Y3WgRo0a5QpmjRs3zs0eAwBAamlWsQMHDmR0M5BB8uXLl+Vm1qMPBQAAsrpcAc3TlwMLbhUvXtwV66QeAgBAwShlmSgwhZxJASkFbRScCke/4X/YFwAAIC37DBmeKQUAQEbSuRlllCQkJLgZQrJatgyOnoKRa9eudceBZpbL6gXNAQAAsgqCUgCAHO3QoUO2Z88eq1ChghUqVCijm4MMUrZsWReY0vGQN2/ejG4OAABAjsDpYABAjnb48GH3f6RhW8g5vPffOx4AAACQ/ghKAQCgIosM2crReP8BAADij6AUAABIZNGiRXEP1AwbNszuu+++dNn2rl277MQTT7TNmzeny/YBAACQcgSlAADIAs4++2zLnz+/FSlSxEqVKmVnnXWWzZ8/37ILzcwyYsSIkKCUajxdfPHFVrhwYVeA/MUXX0xyG1WrVrWCBQu6faSlRIkSwfuKFi1qXbp0sUcffTRdXwcAAABiR1AKAIAsYvjw4fbvv//a+vXrrVGjRnb55ZdbdvHaa69ZixYtrEyZMsHbOnToYOXLl7eNGzfalClT7N5777Uvvvgiye1MmjTJ7SMt27dvD7mva9euNmHCBFfYHgAAABmPoBQAAFmwKLcCLKtXr7ZNmza521atWmXnn3++m0WuZMmS1rp1a1uxYkXwMdddd511797drrnmGpc1VLNmTZszZ07wfgVwrr76apddVKtWLfvyyy8TDX+76aab7Nhjj3XLLbfcYrt373b36Xk01G/8+PF2wgknuCwlZTytW7fOtalYsWIus0vBtGg++OADO/fcc4PX//77b/v6669t6NChLlNKQbhOnTq550gtZVKVLl062cAWAAAA4oOgFAAAWczevXvtpZdecllFCkDJkSNHrFevXi5QtXLlSitUqJALQvlNnjzZBZMUgOrcubMLVHl69OjhbleA6fPPP7dXX3015LF33XWXLV261H799Vf75ZdfbMmSJdazZ8+QdWbPnu3umzdvno0aNcoFuUaOHOkCZwqkDRkyJMkaVgqGeX7++WcX/CpXrlzwtgYNGrjbk3LzzTe7/dKkSRObPn16ovtr167tngsAAAAZL09GNwAAgMxImUEaAuZXoEABFwQ6dOhQMEPJT0EUUTHtgwcPhtynDCTVO1J20c6dO91tyihS1lKs+vbta4MHD3aPP+aYY+zdd9+1PHnyBLOAtHjtfOCBB6xx48YuWJU793/noFSfSbWppFu3bjZgwADbsmWLa5sCVl999ZW7rEVD5ZRVJdrGxIkTXfaUMo1EASZlNj333HPB9vXv399lNSnwU79+fTvzzDOtTp067r7LLrvM3njjjaivbdu2bS6jyqN9768J5e1DvS9JDQFs2LChJSQk2DvvvGNXXHGFa/Ppp58eXEfPoecCAABAxiMoBQBABAsWLEg0zKtu3bqujpOCQi+88EKixwwaNMj9P3XqVFuzZk3IfQrK1KtXz3777Tf7+OOP3W0a0uYFiWKhoWx33323/fPPP3bppZe6rKHmzZu7+xQkUzaTAksqGi779+93QZzixYu766rP5FHwSHS/gmwHDhyw4447Lni//7K2rfu9oJdomJ6275/Nzp/VpEyt8OvhQT4/Bfu8YJ0XsPNeh0fXkwrieftCOnbsaO+//74LTvmDUnqOk08+Oeo2AAAAED8EpQAAiEAZN6q75KcMJC/bRvWVomnbtm3ETClR5lDlypWDgZfUqFixopuJToXBFeyqUKGCy6JSAe8ff/zR1ZXSELVTTjnFAoFAstvTcLe8efO6YX9eIEk1qjzanobfaWifd78uazZAPda/bmppaJ6GBHp1pRTA0+x7KnKurDDRa1JgMFZehpjf77//brfddttRtxcAAABHj5pSAABEoIwcr6i3t3j1mzRkLvw+b+ieKFATfp+G7nkZSt5tKRm6F+7UU091WVZenSZlACkbScEvDcl78MEHY96Whrup/tPAgQNdXSkFgx5//PGQ4I4yjzQkcOvWrW77/fr1c3WpIgV+UqNNmzauJpXnxBNPtGbNmrnnUbBNdao0hPCGG26I+HgFxjRUT9lbCgi+9dZbLmOtXbt2wXUUdFNml4J5AAAAyHgEpQAAyKIUJBo3bpwrbq4glAqRK3CmYM5FF12Uom0988wzLnNLw/aUraSAk58Kl2v4nupFKdurWrVqNmLEiDR7LXo+DZdUwMszadIkN1RRmVqqD/XYY4+5IY8etUOBKtHQQBVrV80rrf/EE0+4wJTqanlUvF3F3b2hiwAAAMhYuQKx5PVnMzqbrPoaqk3hL6oKAMh59u3bZ8uXL7fjjz8+ODwPGUM1s5SpNXz48DTftmpnaTjj3LlzXdAqJccB/Yb/YV8AAIC07DNQUwoAAGQKqouVXjRUUplkAAAAyDwYvgcAAAAAAIC4IygFAAAAAACAuCMoBQAAAAAAgLgjKAUAAAAAAIC4IygFAICZ5cDJaOHD+w8AABB/zL4HAMjR8ubNa7ly5bJNmzZZ2bJl3WXkvICU3n+99zoeAAAAEB8EpQAAOVpCQoJVqlTJ1qxZYytWrMjo5iCDKCCl40DHAwAAAOKDoBQAIMcrUqSIVa9e3Q4ePJjRTUEGUYYUASkAAID4IigFAMD/Z0wRlAAAAADih0LnAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAMiZQanRo0db1apVrUCBAtaoUSObN29ekuuPHDnSatasaQULFrTKlStbz549bd++fXFrLwAAQGZAHwoAAGRlGR6Umjx5svXq1csGDRpkP/74o9WvX99atWplGzdujLj+G2+8YX369HHrL1682F566SW3jX79+sW97QAAABmFPhQAAMjqMjwoNWLECOvevbt169bNateubc8995wVKlTIxo8fH3H9b7/91po1a2YdO3Z0ZwYvuOAC69ChQ7JnBgEAALIT+lAAACCry9Cg1IEDB2zBggXWsmXL/zUod253fe7cuREf07RpU/cYrwO1bNkymz59ul188cVRn2f//v22c+fOkAUAACCrog8FAACygzwZ+eSbN2+2w4cPW7ly5UJu1/UlS5ZEfIzO7ulxZ555pgUCATt06JDdcsstSaaeDx061B588ME0bz8AAEBGoA8FAACygwwfvpdSc+bMsSFDhtiYMWNc/YR3333XPvroI3v44YejPqZv3762Y8eO4LJ69eq4thkAACCj0YcCAACZTYZmSpUpU8YSEhJsw4YNIbfrevny5SM+ZsCAAda5c2e78cYb3fW6deva7t277aabbrIHHnjApa6Hy58/v1sAAACyA/pQAAAgO8jQTKl8+fJZw4YNbdasWcHbjhw54q43adIk4mP27NmTqNOkTpkoFR0AACC7ow8FAACygwzNlBJNZdy1a1c77bTT7IwzzrCRI0e6s3aaSUa6dOliFStWdDUNpE2bNm62mVNOOcUaNWpkS5cudWf+dLvXsQIAAMju6EMBAICsLsODUu3bt7dNmzbZwIEDbf369dagQQObMWNGsHDnqlWrQs7q9e/f33LlyuX+/+eff6xs2bKuM/Xoo49m4KsAAACIL/pQAAAgq8sVyIH52prOuHjx4q5gZ7FixTK6OQAAIBOj3/A/7AsAAJCWfYYsN/seAAAAAAAAsj6CUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAMhaQanDhw/b7t270641AAAAAAAAyBFSFJTasmWLPfPMM3bppZdauXLlLF++fFasWDErWLCg1a9f3+644w774osv0q+1AAAAAAAAyBbyxLLSqlWrbODAgfbmm29aqVKlrHHjxnbbbbdZmTJlLH/+/LZ9+3ZbsWKFzZ8/355//nk7/vjjbdCgQdapU6f0fwUAAAAAAADInkGp2rVr21VXXWUzZ860M88803LlyhV13U2bNtlbb71lDz30kK1evdr69OmTlu0FAADIkn755RfXl/r+++9t3bp1tnfvXitdurTVrFnTWrRoYRdeeKEVLlw4o5sJAAAQN7kCgUAguZVWrlxpxx13XIo2rM2uXbvWKlasaJnNzp07rXjx4rZjxw43/BAAACA9+g3qD7366qv29NNP28KFC61kyZJWr169RNnmS5YssUKFCtnVV19t/fv3t6pVq1pmRB8KAACkZZ8hpkyplAakRNlUmTEgBQAAEC916tSxAwcOWNeuXW3ixIlWq1atiOvt2bPHZsyY4UolnHzyyfbCCy9Yx44d495eAACAeIopKBXprN/06dPt66+/tq1bt7o6U82bN7eLLrooyaF9AAAAOYmynq655hrLnTvpuWWUJXX55Ze7RZlT//zzT9zaCAAAkKmH7/lt27bNLr74YlcPoUSJEm4Wvg0bNrj0cxVAV7BKt2dmpJ4DAIBY0W/4H/YFAABIyz5D0qftIrjnnnvs77//tk8++cRlSS1evNj9r+u6XfcDAAAg+gk+9ZsmTZrk/td1AACAnCjFQakPPvjAhg8fbueff37I7bo+dOhQmzp1alq2DwAAIFtQcvp9991nFSpUcCUPOnXq5P7X9fvvvz+jmwcAAJD5g1K7d+92Q/YiKV++vLsfAAAAoYYMGWJPPfWU9erVyxYtWmTr1q1z/+v6iBEj3Mk9AACAnCTFhc5POeUUe/bZZ61Vq1aWkJAQvP3IkSP2zDPP2KmnnprWbQQAAMjyxo0bZwMGDLCBAwcGb9OJvnr16ln+/PndjHt9+/bN0DYCAABk6qCUzuJdcMEFVq1aNWvbtq3rTG3cuNHef/99W79+vX366afp01IAAIAsTJlRTZs2jXhfkyZNXCYVAABATpLi4XstWrSwb7/91mVMvfHGG+5sn/5XhtQ333xjzZs3T5+WAgAAZGFVq1a1jz76KOJ9mr1Y9wMAAOQkKcqU2rdvn40ZM8ZlSr377rvp1yoAAIBspmfPnnbrrbfapk2b7Morrwxmm0+ZMsXNxDd27NiMbiIAAEDmDUoVKFDA+vfvbw0bNky/FgEAAGRDN998sx04cMAefvhhl2WeK1cuNyNf2bJlbdSoUXbTTTdldBMBAAAyd02pBg0a2O+//25nnXVW+rQIAAAgmzl06JD9/PPPds0119jtt99uS5YssW3btlmpUqWsZs2aljt3iisqAAAA5LyglM7kderUyZ3Vu/jii61QoULp0zIAAIBsQkGnxo0bu9pRLVu2tNq1a2d0kwAAALJeUOrcc891qeft27d31xWUUvq5R5d37NiRtq0EAADI4kGpE044wWVHAQAAIJVBqd69e4cEoQAAAJC8fv36uXpSzZo1swoVKmR0cwAAALJeUGrw4MHp0xIAAIBsTLPsaeY9ZUzVq1fPzb4Xnm0+derUDG0jAABApg5K7dq1y/7991879thjE923bt06K1q0qBUpUiSt2gcAAJAtqP9Uq1atkOsAAAA5WYqDUjfeeKMLPI0bNy7RfYMGDXIdLE1zDAAAgP+ZPXt2RjcBAAAgU0nx/MNffvmltW7dOuJ9mo3viy++SIt2AQAAAAAAIBtLcVBKs8YoUyqSwoUL25YtW9KiXQAAANnKAw88YDfffHPE+3T7wIED494mAACALBWUUnHOzz77LOJ9s2bNsqpVq6a4EaNHj3aPK1CggDVq1MjmzZuX5Prbt2+322+/3dW1yp8/v9WoUcOmT5+e4ucFAACIl0mTJtmZZ54Z8b7mzZu7+1OKPhQAAMhxNaX69OljpUqVsuuvv97KlCljmzdvtgkTJthTTz1lQ4YMSdH2Jk+ebL169bLnnnvOdaZGjhxprVq1sj/++MOOOeaYROsfOHDAzj//fHff22+/bRUrVrSVK1daiRIlUvpSAAAA4mbt2rVWuXLliPdVqlTJ1qxZk6Lt0YcCAAA5LijVs2dP+/vvv61v375uyZMnjx06dMjdd8stt1jv3r1TtL0RI0ZY9+7drVu3bu66OlYfffSRjR8/3gW/wun2rVu32rfffmt58+Z1t6UmOwsAACCeypYta7/++qudffbZie7T7TrhlxL0oQAAQI4bvpcrVy6XKr5kyRIbM2aMm3FP/+u6bk8JnbFbsGCBtWzZ8n8Nyp3bXZ87d27Ex3zwwQfWpEkTl3perlw5O/nkk1121uHDh6M+z/79+23nzp0hCwAAQDy1a9fOBg8enGiI3Q8//GAPPfSQXXbZZTFviz4UAADIkZlSnurVq7vlaGjYnzpC6hj56bqCXJEsW7bMPv/8c+vUqZOrgbB06VK77bbb7ODBgy5AFsnQoUPtwQcfPKq2AgAAHI1HHnnEvvnmGxcYOumkk6xChQpuSN/ixYutQYMG9uijj8a8LfpQAAAgRwel9u3b5zo3+j/cqaeeaunlyJEjrhbCCy+8YAkJCdawYUP7559/7PHHH4/aodIwQ9Vc8OgsX7SaDgAAAOmhePHi9t1339krr7zigkOasbhu3bquNELnzp0tX7586fr89KEAAECWD0opXfzWW2+1119/PVhLKlxSaeB+KpKuTtGGDRtCbtf18uXLR3yMZotRHQQ9zqOzjevXr3dti9Sh0+wyWgAAADKS+imqA6XlaNCHAgAAObKmlFK4P/30U3v55ZctEAjYs88+62beO++881yxzGnTpsW8LXV+dJZu1qxZIWfxdF2p7ZE0a9bMpZtrPc+ff/7pOlrpfYYRAAAgM6APBQAAcmRQasqUKa5I59VXX+2un3HGGdalSxcXqDrzzDNTFJQSpYS/+OKLLpVdNRWUhbV79+7gTDLatlLHPbpfM8fcddddriOlWWZUpFNFOwEAADKz1157zfWXNIyuWLFiiZaUoA8FAABy3PC9NWvWWI0aNVzqd4ECBWzbtm3B+6699lrr0KGDjR07NubttW/f3jZt2mQDBw506eMq9Dljxoxg4c5Vq1a52WQ8qmPwySefuPoL9erVs4oVK7rO1f3335/SlwIAABA3Kn2gYXvXXXedffvtt3b99de7kgc6oVeiRAkXREoJ+lAAACCryxXQGLwUOPHEE23kyJHWpk0bq1Onjpu+WLPJyOjRo12hTM0Ik5mpSKeKje7YsSPFZyUBAEDOklb9hlNOOcWuvPJK69Onj6vtNH/+fDc5zK5du+yCCy6wq666KqSoeGZEHwoAAKRlnyHFw/fOPvts++qrr9xlne0bNmyYXXHFFS5D6p577rG2bdumdJMAAADZ3l9//eXqOinbXIs6a1K0aFGXrfT0009ndBMBAAAy9/C9Rx99NJgJdffdd7ti52+//bbt3bvXevTo4VLIAQAAEEpnC/fv3+8ua+jc77//7k72iYbxbdmyJYNbCAAAkMmDUppm2D/VsOoSaAEAAEB0p512mv3888/WqlUru/TSS92MxpoJT0P5lHneuHHjjG4iAABA5g5KAQAAIOU0E97KlSvd5YceeshdVta5AlOnn366Pf/88xndRAAAgMwdlDp48KA9+eSTNmXKFFu9erXt27cv5P5cuXK5QlYAAAD4H2VCedlQmm1v6tSpbjifFoqGAwCAnCjFQanbbrvNXn31VZd2fuGFF1q+fPnSp2UAAADZXP78+d0CAACQE6U4KPXuu+/aU0895YJTAAAAiN13332XZLa5sqcAAAByihQHpYoUKWInnHBC+rQGAAAgmxo1apSbHOaYY46xE088kWxzAACQ46U4KNW7d28bPXq0nX/++ZaQkJA+rQIAAMhmnnjiCbvjjjts5MiRljt37oxuDgAAQNYLSvXo0cPWrl3rzvC1aNHCFeoMTz3XmUAAAAD8z+7du61t27YEpAAAAFIblJo0aZI706fg06xZsxKlnhOUAgAASKx9+/b28ccf23nnnZfRTQEAAMgUcgUCgUBKHnDcccdZkyZN7IUXXsiy0xfv3LnTihcvbjt27MiyrwEAAGStfsP+/fvtxhtvtMOHD1vLli0TZZvL5ZdfbpkZfSgAAJCWfYYU549v3brVunfvTkcEAJDt/fPPP3bddddZuXLlrECBAla7dm03A+2RI0eSfNyKFStc5nCkJTwQMX/+fOvSpYtVq1YtuE758uUTbXPLli3WsWNHq1GjhvsbnDdvXqtQoYJdeeWVtmjRojRrO9LPkiVL7JtvvrE333zTBaf03vmXq666KqObCAAAkLmH71188cU2d+5cUs8BANnaxo0brWnTprZq1argbYsXL7ZevXrZn3/+aWPHjk2T5/n666/ttddeS3a9bdu2uSH0fuvWrbN33nnHDQn79ddf7fjjj49r25Ey119/vZvFeNq0aS64yOx7AAAgp0txptQNN9xgL7/8svXr188+//xz+/HHHxMtAABkdYMHDw4GdV566SUX6Lnkkkvc9eeee87mzZsX03aWL19uGinvLdu3bw+5v2bNmvbggw/azJkzrWLFilG3U7RoUVfT8Y8//rC9e/e64FLjxo3dfXv27LH3338/zduOtKXA4GOPPWatW7e26tWru5II4QsAAEBOkuJMqQsvvND9P2zYMLdomIFHnW1dV60EAACyKg1xe+ONN4JBI2W4iE7IfPjhh+7yxIkT7Ywzzjjq57rooovcInnyRP+zrGF4vXv3Dl5XUEPD+b777jt3XcP54t12pEyDBg1sw4YNGd0MAACArBuUmj17dvq0BACATGLZsmWuKKPUqlUreLv/cqyZwQr+aOhd2bJlrVWrVvbII48kmREVC538Wbp0qQsuSZkyZVxNorRuO9LWmDFjXJ2vY4891s4999wkg5AAAAA5QYp7Q2eddVb6tAQAgExi06ZNwcv+iT38lzUkLiXbUv0nDX/XML2FCxe6IFVqKGP5k08+CV6vXLmyTZ8+PVgcPS3bjrTVvHlzO3jwoMuMy507txUsWDDkfmWbewFFAACAnCCmoNShQ4dSdTYvtY8DACAz0jB1j3/4erjChQvb0KFDrU2bNnbCCSe42fg029q3337rZsUbPXq0q/uUFlavXu0CVZrVLamaRLG2HelHwy/Z9wAAAP8TU8RIs/moI9W5c2crXbp0TDMJjRw50tVO6N+/fyxPAQBApuHPYvJnruzatSviOpEe36dPn+D1k046yRUp14x48sMPP6S6bTNmzHAnfVauXGkPPPCATZ482QW6tP1nnnnmqNuO9JNWgUgAAIAcFZTSTD0KLt13331u+F6zZs2sXr16rlObP39+N5OQZhdasGCBG1KgoQO33nqr3XLLLen/CgAASGPKbipRooT7+6bZ7jxLliwJXj711FOjPl7FxjU8y8+fIXO02TLKQj7xxBOtb9++Liglf/31V5q0HQAAAIiX0B5zFJq6WPUvFHCqVKmSm15aBVUVoGrSpIkbNnDXXXfZb7/9ZnfffbebhvrJJ590hVcBAMhqFFDq0KGDu6zAzoQJE9wJlyFDhgTX6dSpk/u/atWqLsh09tlnB+/TiZx7773XfvnlFztw4IALCPlnztPJHc/+/ftt8+bNblEwyxtq592m++XZZ591Nal0Eki3KVPq8ccfD25HwaiUth3pr3379rZo0aKY19+3b597r8ePH5+u7QIAAMgMUlTw6ZxzznGLrF+/3hVtVeepVKlSrlOurCkAALLLUKuPPvrInWi5/vrrQ+5TJrBm1Ytmz549NmrUKDekLpxmwbv99tuD1ydNmmTdunULWUeFyL0hdgoqaca2+fPn2yuvvBLx+fR3uFevXmnSdqStKlWquCBkjRo13Ak9L9tc75koaOllm3/88cf2wQcfuHWVpQ4AAJDdxZQpFYlm+TnllFNcplTNmjUJSAEAspVjjjnGFSbv0qWLCxDly5fP1YYaMWKEK1SeFAWRFHiqU6eOFS9e3D22WrVqds8999jcuXNDZsKL1aWXXmqtWrWyChUquO0VKFDABS80XP7HH39020+LtiNtKZtt6dKl7v1Tpvm5557r3pO8efNaoUKF3Ax8tWvXdsfMzp07beLEia7mWMOGDTO66QAAAOkuV8A/HU8OoU6ffiSoAGxqfhjkVCqkq6K6OpOrfaehIt27d3dDN8Nrp0SjzDr9SFu2bFlwWMObb74ZvF9TZevssDdERWeQNd35ZZdd5obClCxZMmR7r776qiuqv3jxYtex1/AZDVFRJoLnq6++ctvTD0Fl96lAsNquH2t33HEHAVUAQNz6DX///bcLOvmzzXVyT9lrClJldvShAABAWvYZCErRoYqJhpKcfvrpbihIOA0FGTt2bEzb0ZCSBx98MHg9PCh100032YsvvhjxsTprPG/evGAAbNiwYa7IbzgV+FUAygtMqX3PP/98xG1efPHFbogLgDRw5LBZ7oSMbgVyqnQ8/ug3/A/7AgAAxIKgVBLoUKXcbbfdFgw8afhBmzZtXJ2SDz/80N32/fffJ1ujRGeHTz75ZEtISLDdu3cnCkrpUNRZYp05Lly4sH3zzTdumIoK6WtoiqjmhmaNWr16tRuqokwqBatUg+Pnn3927VIm1EUXXWTTp093j9EQGtV38YbSfPfdd9auXTt3HIjOWJ922mnpuPeAHOSZnmb//J3RrUBOU/FEszufSrfN02/4H/YFAABIyz5DigqdI2fSbFBvvPGGu6whBl7R3H79+gWDUqqBkVxQ6s4773QBJ2U49enTJ9H9mr1KAStR8Kp+/frucsuWLYNBqb1797r/p0yZ4gJSohotCl5pUa2OTz/91M0UqVmrNAOknq9o0aLB51Gxfg3d0+xG3jTqBKWANKKA1IrfMroVAJCjSiCsWLHCjj/++CQfP3v27OAsoWPGjHEn9HSiTu2R+++/3/WZwvtmSfEmYgAAIO6FzpFzqPPjdVj8tZr8l72gUTTvvfee64idd955rhMVzc033+z+//XXX+2nn35y05jPnDnT3abCsCquH/58kdqkQJoeL/6AlL9j56lYsWKSbQcAADiaEghNmzZ1s2fq8v79+10tTM2Y6Z+JMzkKGHkBqdQoUqRI8PILL7zgTuB5/bu02CYAAKkRU6aUMkmuueYae/jhh10NnkgUcOjfv7/LYNHZn6xg/fr1wWFkopmMVEhbw78UDAl37LHHuv+VgaOC3OF1jFRoW9vzhoV5NOtR6dKlXaBkw4YNibarWZKUIbR161bXUfFTQEV/8JUhtH379pD78uTJE5wyXAVTwylLSLP76HFehpFHw+OUQqfn0/P66YxduXLl3GW1Vx0nj7anx4QXB1+7dq1rg/aB9oX2j/aTaOhcjx493H4In/VJ7fLarsdp+nTt/6efftoaNGgQXK9u3brubJyeV+uvWbMmJMCkfat2q32eP/74w81opNep1+vtQ82CpMwu0RDAM888M+o+1P7Vft62bVtIIEv0vuj9ibQP9X7qffX2odrnp+NB+0PHiv8YFA1hVJqjfx/6z1hq5kvRMap95afjV8fxv//+a7t27Qq5zzu+Dx8+7DrF4bRdbX/Lli3BLDSP2qN26b0M78B6x7eGX+ozFe34jrQPveNbt+v+aMe3ths+0tg7vtUetSvS8a3XodcT7fjWftD+8FPRYR1n2n/aj5H2Id8Rod8RIcd3roJWKncey3/kkO3MU9B25ykY8tiCh/ZbiUO77WCuBNucv3hogwJmx+7/77k25Stuh8LqA5U48K8VPHLA/k0oYLvyhhaEzn/4gJU6+K8dtly2sUDohAhSbt82y20B25K3qB1I+N/3hBQ7uNsKH95ve3Pns+35Qn9g5T1yyMoc+O/9WlegVKLtlt2/3fIEjti2vEVsX0K+kPuKHNprRQ/ttf2589rWfKHB8YQjh+2YA/99ljbkL2FHcoWeIyq9f6flC2gfFrLdeQqE3Ffo0H4rHmUf5goErPz+bVH3YckDu6zAkYMR92GBwwespNuHuW1jgRKJXmv5fVtNORNb8hW1A7lD92Hxg7ut0OH9tichv+3IWzjkvnxHDlrpA7v09tr6CPvwmH3bLcEi78OiB/dYkcP7bF/uvLYtbB/mOXLYyv7/Plyfq6AFwo7xtPyOCP8+BVJC9TS9mpzhJRA0uUu3bt1iKoEwfPhwd+yG9xukatWqif5O6ntdWeT6jlemuz8rXBPI6ESg/u5rBs9oIlX50EyeS5YscX/Xov0uAAAgTYNSTz75pPvRk9QfHtXweeyxx1xQQSnBWYGCHPqR6Q98XH755e4Ho84ghRs0aJD7f+rUqSFBEe+Pe7169ey3335zATq/E0880a699lr3IzXSdjX8TJ0MnbH6888/Q+674IILrEmTJu7M2Ntvv50oiOBlFqmTE/7jWp0M/Zj98ssvbeHChSH3NWvWzA2L0w9VnbkL/5Grs3ei4M3vv/8evE/t02PU+VHRcY86/XptymTStNcKMHiv9bPPPnP7q0WLFq5TpBRzfyfLW+/KK690RccVkAqnGlJ6DcqE0vr+/T9p0iT3vAokKIDq+fzzz13gQMemOnu6T/tJr1cdNa3fqVOnYNp8pPdGQw4VpFDK+y+//BJy31lnneXS4NU2L8jlUeBCgThvhsDwH0TqjGpWQRVkV+q8nzqNrVu3doGN8DYpeOEVd1cAODwwouCx9rH2lV6/nwJ0V111levMRnqtGlagIMa0adNs5cqVIfepA61aXuqE6n6/4447zqXu6/iLtN2ePXu6H386DvzHkmi4ZfPmzd3z+Qvei4IpqmXmfVbDA2Uqiq8g0Ndff23z588Pua9x48bWqlUrFzAZP358yH0KrmkmR9FzhgfDdEwoWKn6ZV988UXIfXxHRP6OCPnBXqC2dS2w2qru2WDzStayb8rUDXnsKdv/skvXzXUBiBeOvyRRoKb/H/99lt6teKatL1A65P4r13xhdXattF+KH2+fljs95L4au1ZbhzWzXVAjfLvS549Jlv/IQfu4fCP7u0iFkPsuWv+9nbHtD/urSEV7r2LzkPsq7dlkN6z87/2KtN07l75npQ7ustllG9gvxUNPyJy16Sc7e/NPtrpgWZtYpWXIfSUP7LQef7/vLr9a5QLbExZ4un7FdKu8d7PNLVXbvitdO+S+07YusdYb5rmAVHib8h0+YH3//O+zNKXSWbYpf2hw6ZrVn1vNf9fYwhLV7PNjTg25r/bOFXbVP1+6IFik1/rAktddAG5a+Sa2svB/wXFPm3Xf2qnbl9qSopVt2rFNQ+47bvd6u27Vp3Y4V+6I2+3519tW7NAe++yYU+33YlVD7jt344/WfMuvtrJQOXuz8rmJAoK3LfvAXZ6Qv6YdCPvspOV3RHhAHchsJRAiUf/IO1kRHnjy/l7NmTMnRa9HfQv1BUR/+7PCjJEAgMwtpkLnynzSH6+uXbsmud5rr73mzgYp0JAVCm4pk8Y/tIssiMhZEHo/9QPV+wGsGgQK6CiQoOCUqDP1/vvvJ8qUUjBGwRDtWx0fVapUcVlVCrqIgjrqmOlHuV6PggF6rI65119/3QWEFITR8D9RkKB69ep2xx132Lvvvutu0w91/XhWu/UD3PtRP3nyZBfw8DKlNJxPASrtK+1XtUevS/sp2j4kU+o/ZEqF7kO+I5LIlHr6biu1chGZUmRKxTdT6vjTLNBjZLpmSimgkFbFvZWBrECZTmooSKHvX2Xx6nkjDTnPTCh0njJ6X9VvkbZt27q+kuhvnv7eiDK2v/rqq6jbUB9IJ0RUAmHcuHHB2lHhMxiH06zJOs7091t9L71v4RSUUq3NaDWlwunklk6AqL+g4FSNGjVi2g8AgJxnZ1oWOldxRgUNkqM/klo3q1AnMNLO0Q8578dlJF4QIxJ1dLVEoo5uUtv1OieR6MeslmiS2q5+DGuJRD++k3qsOsj6UavH64erAlHe0D11cPxnnf3b0Q8BXddj1OnXos5YpM6QFmVpKDDh/ZBX0ErZH3LjjTeGBKWUcaVgkheU0g9mL9vJy8LSdWXheO+VslO8s+LazwpkhRc3T2o/KBARTSz7MBodf9E+oN4+jMYLNkSiIEW0Og8KbiS1XQVHolHHNtpZUXVQU7sPFexJ6rFeIC4SfdFF6mh7wZ6ktusFDiPRD8NoPw75jkji+A7sNTvyX7C02KG9bokkb+CwHbsvNNjl5wUbIlGQQkskCRZIcrulD+4yC40XBingVTCJxya1XQVzom1XGVpJPbbc/tBgop8yiLTEdx8eSXofHog+lE2BKS2R5DqKfahAWlKPLa/jLspxmhbfEdE+syml4Jj+pr311lvuO1MBXc0wq+84nYBRP0pZ58g+/Ccw/H/v/ZcjnSjyHzPKOI5UAiEpCkZ5GYIdO3aM+hlICZ3c8IJqCpARkAIAxK3QuX7cRsoKCKfsgLTquCHz0A/lDh06uMvKLtNQKh0PQ4YMCRnyJMqcUkfbm90lJfw/DBQ0UoaWoqrKmPJ4P5x1pk4dNNGQUXWUZsyYERyypgCUFxhYtGiRa48CUvoBrSAYs+0BAOJNQ3H1d2r69Onu7KE/A1QlEvR3DDmD/71Paoa7Rx55xJ0Q7N27t8vWi9XYsWODl5OqGZUSytLyMrTTapsAAMQUlNIPeA2FSo5SiPmxnz1pWKaG3omGGujssVcL4ZZbbolaC0FBJHW8/Mvy5cuD9yv1XLepqLlqE11xxRXudtXN0VA+PV41EURBJm/mPtVjevDBB91l1f5RIU8NzVNnSY8ZMWJE8DlGjhwZHAanwJTq+qgD6C16bQAApDcNe1Kxag2F906seHRSx19zEdmDP6vZP/zdP8Q+WuazsqRU11VZTpdccok7yeavzahsdN0WPvxat3vD+ho1auRqQh4tf91IzVqs+qEAAMQtKKXpapVqriBAeP0VUfr5Qw895Aovq9YPsh8Fob799lvr0qWL6zypM63ZVxT8SUk6eXKUFaVZHk8++WQ3FEnDpCpVqmSdO3d2BcH9w61U6PPll192Rc69Wj8qJq3i4SqIDgBAZqI6ddGGC0aaUQ1Zn2pkelneyjb3eMXCJVrQyCt/oGCWyhaov+PV5PSyynWbf7uivpFXR82bMORoaZITbwIPTSKg/hkAAGkhpr8oOhty3333uaDU888/78aRK2tGWSaa4nbWrFmuELFmq9EsXciedGYsfBaucLGc5Y00bbFHwaX+/fu7JRYqvp9cAX51zrQAAJCRlKn7zjvvuEypcJp9lmzz7FsCQcPpvBIIynqKVgJBQ/U0u29KZ8Xze+6554I1Iq+++uqI6yjQpTqe/uwtZVx5meXhtRG94YCqd9m9e/dUtw0AgHAxn+bQbBwqMK00YqWfezNAKYigszcaZ67hUwAAAEhswIABbtIPZbGoNqJO7s2bN88NUx8/fryrNYXsR2UCFHTUiVyVQPCLpQRC+Mm/pGbfU80yL3NKz6V+eiQ6DjV5jN/TTz/tFvE/r2YQnDlzprvcrl27JCcHAAAgpVKUe6sinFo0hM+bQllnYTSbF0IdPhKwhNzRC1cC6YVjDwAyJw29UhBBmeUTJ04MDq/SMHVdVyY6sm8JhH79+tnHH3/sspM0q7Uyju666640fS4vo0kBTwW80oJGSXhBqrQaDggAgCdXINo4qmxMM96oaKQ6Bf4pedNaz8/22dJtR9Jt+0C4aiVz21MtI58VBeKiz6VmK37L6FYgp6lax2zYB5m636CJOH7++Wc3UYdqM2pCDw2VKlWqVJaqgxivPhQAAMjaYu0zxJQpFZ5q7Kex5ToDpPHvLVu2TF1rsykFpH7bTFAKAICcTrWFGjdu7Iboqb9Uo0YNtwAAAORkMQWlFi5cGPU+DeVbt26dPfrooy4w9eGHH1rhwoXTso0AAABZPiilmdi2bduW0U3J9BiGjozCsQcAWTAo5fnqq6/ssssus0GDBtkTTzyRFm0DAADINlRT6OGHH3YTxFSoUCGjm5NpKShACQTEGyUQACALFDpPSvPmzW3gwIH21FNPEZQCAAAIM2XKFNu0aZPLmKpXr56VK1fOFaT26PLUqVMztI2ZBSUQAADIGdIsKCV169a1tWvXpuUmAQAAsoV///03pKi5rgMAAORkaRqUUkBK1dUBAAAQavbs2RndBAAAgEwld1ptaNeuXfbYY4/Zueeem1abBAAAAAAAQE7OlOrRo0eSs++tX7/e5syZY3ny5LF33303LdsHAACQbWjymCFDhtjXX39tW7dutVKlSrm6nH379rVTTjklo5sHAACQ+YJS06ZNi76BPHmsbNmydtNNN9ldd91l5cuXT8v2AQAAZAuaqfj88893faUOHTq4QucbNmyw9957z5o2bWozZ860M888M6ObCQAAkLmCUsuXL0//lgAAAGRjffr0sbPPPts+/PBDd1LP8/jjj1vr1q3d/cqgAgAAyCnSrKaU/PXXXzZ48OC03CQAAEC2Gbqnkgj+gJQkJCS423/88ccMaxsAAECWDEqpntTIkSPt9NNPt5o1a9qwYcPSpmUAAADZSOHChW3jxo0R79MwPt0PAACQk+RO7Ux7L7/8squLULlyZevdu7cdOnTIRo0aZf/880/atxIAACCLa9Omjd1///322Wefhdyu6yp0fumll2ZY2wAAADJtTSk5ePCgffTRRzZx4kT3/759++yEE05w6ebKlFJAqkWLFunbWgAAgCzqySeftN9++81atWplxYoVs2OOOcZlTu3cudNlnD/xxBMZ3UQAAIDMF5Tq3r27vfvuu7Z9+3bXgdL1jh07WqNGjWzHjh321FNPpX9LAQAAsrCSJUva3LlzXaFzFTTftm2blSpVys24p0LnuXOnaalPAACA7BGUeumllyxXrlzWsmVLe+GFF+y4445L/5YBAABkMwo8aZgeQ/UAAABirCmldPNTTz3VZs6caSeeeKKde+65Nm7cOJc5BQAAgOTNmjXLJkyYEPE+1eqcPXt23NsEAACQ6YNSPXv2tB9++MH++OMP69+/vytmftNNN1n58uWtffv2LovqyJEj6d9aAACALEp9KM2yF8mmTZvc/QAAADlJiooXVK9e3QYPHuyCU99//73deuut9vPPP1sgEHBp6Ndff73NmTMn/VoLAACQRanI+WmnnRbxPmWk634AALIDJbJcd911Vq5cOStQoIDVrl3b1aJOLpll6dKldsUVV7hJ1QoXLmz58uWzKlWquG0tX7480WRszzzzjDVs2NDVaCxSpIiddNJJ1q9fP1e3MZxGevXp08dq1Kjh2qTHnHHGGfbaa69FbIsmd9NIMSXhaLnmmmuOcq/gqGbfC6dZYrSMGDHCPv/8czcr33vvvWevvPKKHT58OLWbBQAAyJbUodUEMZGo80z/CQCQHWhm2aZNm9qqVauCty1evNh69eplf/75p40dOzbqY1esWOEmWfNbvXq1izN88skntmTJEitevLi7/fbbb7cXX3wxZF3dP3ToUPv0009t3rx5wUlE1KYWLVq4BBvP/v373Ygwbbdz586J2jJs2DBbtmzZUewJxCJ3WnSwzjvvPBs/frytX7/epkyZcrSbBAAAyHY0a/Ho0aNdhrmfro8ZM8bdDwBAVqfRVV5ASpOmKSB0ySWXuOvPPfecCxZFc+yxx7p1lBW1d+9eW7RokctWEsUblBDj/e30MpyUUaX19DzKPJYFCxa42zx33HGHC0gpfqFg07p162znzp321VdfWbt27RK14++//7bhw4e7bSMTB6V0Ri8hIcF+/PFHdz1//vx2+eWXp1XbAAAAso0HH3zQvv32W6tXr56bROaNN96wJ554wurXr+9uf+SRRzK6iQAAHBUNz9PfN6lZs6Yr8VO2bFk3pM6jUVbR1KlTx26++WarWrWqG2Knv5Ft27YN3p83b173v4JLikXIySef7NbT87Rs2TK4roJasmbNGnvnnXfc5Wuvvdbuv/9+Vx+7aNGiduaZZ9qVV16ZqB133nmnG743YMCANNgrSNdMqfCzfQAAAEisSZMmbga+YsWKuQ6xOsaqbaFhCLq9cePGGd1EAACOioa7eUPVa9WqFbzdf9lLakmOakYtXLjQpk6dGqxxrVFaHgWv5Ndff7WffvrJTRoyc+ZMd5sCVKeccoq7rGwor5aV4heq71ioUCGrVKmS+zt84MCBkOdVWaKPP/7YPZcmdkMWGL6XFpTO7kVDlb6eVEqf35tvvunaECnlDgAAIDNp1qyZffPNN7Zr1y535tYbOqDbU4P+EwAgM1FgyKOTMJEua5hdchTEUpFzDcfTULq6deu6oXsFCxYMrqNs43vuucd2795tDRo0sGOOOcYFsXRZQSUFnryaVJ7XX3/dDe1TFpWKsWuIXpcuXYL379mzx3r27OmeW39jkUMypSZPnuyKng0aNMhFTZV616pVq2QPVhVB00HYvHnzo24DAABAvKhTXaFCBdeR1png1KD/BADIKvxxg9Qktvzyyy924YUXhkwY8vjjj7vAVLgNGza44JTn0KFDIcEx1ZpSTSn93fT+nv7+++/usobSr1y50nr37u2GHyKTB6U0hlNpcF4xsdTSDH7du3e3bt26uakiVdhMUU0VT0+qnlWnTp1cfQZNFwkAAJDZaFafSGda1cfR0ALVtNDwPQWJUnqij/4TACCz0d82jz+ApAzhSOtEo1n0NKxOQ/POPfdcd9tvv/1m48aNC2Zk9e/f312uUaOGLV261LZv324dO3Z0ASf9fVRmspQuXTq4XQ3JUzBKf3+1rufnn392WVKq+ai/yyrMruCVF6wSbV+3ebWqEMeglKZKfOaZZ+y7776Luo7u0zrh4zGTo/WVPucvSKZpG3V97ty5UR/30EMPufS8G264Iab2Kz3evwAAAKS3xx57zKZPnx5y29dff+06ywogaYiAOshPPfWUvfrqq5mq/yT0oQAAKaETHiVKlHCXNdudP8jkiTWpRUXNVfi8R48ewdv++usv97+G9HmZxsoS1gx9CibpxIvHm6nPqy2VXAaz/rZqUTBNw+r1uNatWwfX+eSTT9xt/teFOAWlNE3xo48+GlKcLNxJJ51kQ4cOteeffz5FDdi8ebM7a1euXLmQ23VdUz5Gos6cppZ88cUXY3oOtUsHqLdUrlw5RW0EAABIjfnz5yeq26SMJnW0v/zySzfsYNq0ada5c2d3e2bqPwl9KABASugESYcOHdxlBW8mTJjgspqGDBkSXMcLHKkmoobynX322SEnT6ZMmeLqQClApG34M469LN9jjz02JFikIJWCSaoZ5fGCY6effrpVq1bNXdbEIiqKrr+V3iyBqh+lyUiQiYNSKoapKRG9NzUSdVTuuOOOJKd3TAtK+1PHTR2qMmXKxPSYvn37ugPUW/yFzgAAANKL6lpotiC/GTNmuHpOxx13XPC2q666ynWoM1P/SehDAQBSavDgwValShV3+frrr3cZuh9++KG7fsstt9gZZ5wR9bHKbrr66qvd4/Pnz+8SY7wZ9RTEuvHGG91l/Q294oor3OU///zTBZ0Ur5g0aZK7TX/rvJnzFPjyTggp41eF0BXUUnBKBgwY4Nqox2sovX9Zvnx5sG3anm7T45F28sSyksZu6kxZcjSVcSzr+elgUW0qddr8dF3jPMOpw6YCnW3atAne5k3vmCdPHhdJVeqenw5mLQAAAPGkk3b+IW/qp2zdutXOPPPMkPVUeFW1LDJT/0noQwEAUkoBnm+//db69evnZsHTSQ39jdHQ9bvuuivJx6rOk4JIGu63ZcsWF0hSdtTFF19s9957r5UqVSq4rrKiFCBSoXJvOJ/+Bp5zzjluEhC1w6Oh8rNnz3YBM5UeUvFzDQ1Ue3TSBpk8KJWSwpteBydWSpVr2LChS6Pz0tu1DV1X5lU4RUpVed9PBc50BnDUqFGklQMAgExDtSdUePzSSy9115VRrs62v0aFVyPDPxQhOfSfAACZWcWKFe2VV15Jch2dLAl30003uSUWBQoUcH/LvILnyVGdKC/rKlbKzkrpRCRIh6CUIpOqXO9VvY9G66RmJhdNZ9y1a1c77bTTXCrfyJEj3RTJmk1GunTp4g5qZWHpwDv55JNDHu8NKwy/HQAAICMNHDjQWrRo4aaV1hlb9ZUuuOAC1+fxe+edd1zGeUrQfwIAADkiKHXllVe6WWH0vwqaR7J48WLXGbr77rtT3AiNzVTxM3XcVHBMKXiqt+AV71y1apUrmAYAAJCVKNCk4QKqZbFt2zZXt0LDD/w2btzohtApiJQS9J8AIJs4ctgsd0JGtwI50ZGMP/ZyBWLIRdNZN3WqlF536623uikXVXhM6efq8Kja/dixY11qm6YhLly4sGVmqu2gGg8a26oaDumlzZQ99tvmlA1nBI5GnTK5bdpVhTK6GcjJ+lxqtuK3jG4FcpqqdcyGfZDl+w1ZAX0oZFf0oZDhnulp9k/6TXgBJFLxRLM7n7KM7jPElCmlINOcOXNcQOrJJ590SzhlUY0ZMybTB6QAAAAAAMhUFJDixB5yoJiCUlK6dGl76623XGbUl19+aWvXrnW3q1aBaiVQIBMAAAAAAABpHpTyaNjetddem9KHAQAAAAAAAKkLSh04cMCmTJniMqXWrFnjbqtUqZKdddZZbviepicGAAAAAAAA0iwo9fXXX1vHjh2DwShvGuHt27fbiy++aP369bOJEydas2bNYt0kAAAAAAAAcqiY5glesmSJXXTRRVa0aFF7/fXXXfX0rVu3ukUV1RWMKlKkiFvnjz/+SP9WAwAAAAAAIPsHpR566CGrXr26zZ8/32VLKTjlUTCqQ4cONm/ePKtRo4ZbFwAAALF75513LCEhIaObAQAAkPmCUp9//rnde++9VrBgwajrFCpUyHr37m2zZs1Ky/YBAAAAAAAgp9aUUt0oFTRPjtbRugAAADDr0aNHTOv9/fff6d4WAACALBmUUrBp0aJF1rx58yTXW7hwYUzBKwAAgJzg2WeftZIlS1qxYsWSXG/Pnj1xaxMAAECWCkpddtll9sgjj9iFF17oaktFsnTpUhs6dKh16dIlrdsIAACQJZ1wwgl29tln27hx45Jc7+2337b27dvHrV0AAABZJij1wAMP2NSpU61+/frWtWtXu+SSS6xKlSruvlWrVtlHH31kr7zyilWuXNn69euX3m0GAADIEho1amTff/99suvlypXLAoFAXNoEAACQpYJSJUqUsK+++spuvfVWe+GFF9wSrl27djZmzBgrXrx4erQTAAAgy+nWrZvNmDEj2fVOP/10mzBhQlzaBAAAkKWCUlKuXDl79913XWbUl19+af/884+7vWLFitaiRYtg5hQAAAD+07JlS7ckR/0oZaMDAADkJDEHpfydpmuvvTbq/bt27bKiRYsebbsAAAAAAACQjeVOqw1t3LjR1ZMiYwoAAOA/9erVs19//TXktjfeeMO2b9+eYW0CAADIckGp7777ztWUat26td155532119/uds3bNhgt99+u1WtWtUef/xxVwQdAAAA5gJSe/bsCV4/fPiwde7c2ZYtW5ah7QIAAMgyw/c+/vhja9OmjZsVpmzZsjZz5kybNGmSvfbaa9alSxfbtm2bdejQwQYMGGA1atRI/1YDAABkUcyyBwAAkIJMqSFDhtgpp5xiq1evtvXr19vWrVtd0c62bdtaoUKF3FTHClARkAIAAAAAAECaBaUWL15sDzzwgFWoUMFdL1KkiD322GN26NAhGzZsmDVs2DCmJwMAAMhpcuXKFdNtAAAAOU1Mw/eUGeUFpDwVK1Z0/1evXj19WgYAAJANnHPOOZY7d+h5wObNmye6TYGqHTt2xLl1AAAAmTwoldQZvYSEhLRsDwAAQLYxaNCgjG4CAABA1g9KRTrLF+lMH2f5AAAA/kNQCgAA4CiDUnSoAAAAAAAAkJYISgEAAAAAACBzzr4HAAAAAAAApCWCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAIg7glIAAAAAAACIO4JSAAAAAAAAiDuCUgAAAAAAAMi5QanRo0db1apVrUCBAtaoUSObN29e1HVffPFFa968uZUsWdItLVu2THJ9AACA7Ij+EwAAyMoyRVBq8uTJ1qtXLxs0aJD9+OOPVr9+fWvVqpVt3Lgx4vpz5syxDh062OzZs23u3LlWuXJlu+CCC+yff/6Je9sBAAAyAv0nAACQ1WWKoNSIESOse/fu1q1bN6tdu7Y999xzVqhQIRs/fnzE9SdOnGi33XabNWjQwGrVqmXjxo2zI0eO2KxZs+LedgAAgIxA/wkAAGR1GR6UOnDggC1YsMClkHty587trussXiz27NljBw8etFKlSkW8f//+/bZz586QBQAAIKuKR/9J6EMBAIBsHZTavHmzHT582MqVKxdyu66vX78+pm3cf//9VqFChZCOmd/QoUOtePHiwUXp6gAAAFlVPPpPQh8KAABk66DU0Ro2bJi9+eab9t5777kin5H07dvXduzYEVxWr14d93YCAABkpf6T0IcCAADpKY9lsDJlylhCQoJt2LAh5HZdL1++fJKPfeKJJ1yn6rPPPrN69epFXS9//vxuAQAAyA7i0X8S+lAAACBbZ0rly5fPGjZsGFJk0yu62aRJk6iPe+yxx+zhhx+2GTNm2GmnnRan1gIAAGQ8+k8AACA7yPBMKdF0xl27dnWdozPOOMNGjhxpu3fvdrPJSJcuXaxixYquroEMHz7cBg4caG+88YZVrVo1WDuhSJEibgEAAMju6D8BAICsLlMEpdq3b2+bNm1yHSV1kDRVsc7gecU7V61a5WaU8YwdO9bNOnPllVeGbGfQoEE2ePDguLcfAAAg3ug/AQCArC5TBKXkjjvucEskc+bMCbm+YsWKOLUKAAAg86L/BAAAsrIMrykFAAAAAACAnIegFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAADijqAUAAAAAAAA4o6gFAAAAAAAAOKOoBQAAAAAAAByblBq9OjRVrVqVStQoIA1atTI5s2bl+T6U6ZMsVq1arn169ata9OnT49bWwEAADID+k8AACAryxRBqcmTJ1uvXr1s0KBB9uOPP1r9+vWtVatWtnHjxojrf/vtt9ahQwe74YYbbOHChdauXTu3/Prrr3FvOwAAQEag/wQAALK6TBGUGjFihHXv3t26detmtWvXtueee84KFSpk48ePj7j+qFGj7MILL7R7773XTjrpJHv44Yft1FNPtWeffTbubQcAAMgI9J8AAEBWlyejG3DgwAFbsGCB9e3bN3hb7ty5rWXLljZ37tyIj9HtOjPopzOD77//fsT19+/f7xbPjh073P87d+609FQ53z47WOhIuj4H4Fc5X27bufNQRjcDOVmpSmb7D2Z0K5ATj7t0/Jvu9RcCgYBlFvHoPwl9KOQU9KGQ4ehDIYf2nzI8KLV582Y7fPiwlStXLuR2XV+yZEnEx6xfvz7i+ro9kqFDh9qDDz6Y6PbKlSsfVduBzGhsRjcAADLC/en/7bdr1y4rXry4ZQbx6D8JfSjkJPShAOQ492d8/ynDg1LxoLOI/jODR44csa1bt1rp0qUtV65cGdo2RI6oqrO7evVqK1asWEY3BwDSHd97mZvO8KlDVaFCBctp6ENlHXyPAMiJ+O7L+v2nDA9KlSlTxhISEmzDhg0ht+t6+fLlIz5Gt6dk/fz587vFr0SJEkfddqQvfanwxQIgJ+F7L/PKLBlS8ew/CX2orIfvEQA5Ed99Wbf/lOGFzvPly2cNGza0WbNmhZyF0/UmTZpEfIxu968vM2fOjLo+AABAdkL/CQAAZAcZniklSgvv2rWrnXbaaXbGGWfYyJEjbffu3W42GenSpYtVrFjR1TWQu+66y8466yx78sknrXXr1vbmm2/a/Pnz7YUXXsjgVwIAABAf9J8AAEBWlymCUu3bt7dNmzbZwIEDXbHNBg0a2IwZM4LFOFetWuVmlPE0bdrU3njjDevfv7/169fPqlev7maOOfnkkzPwVSCtaJjAoEGDEg0XAIDsiu89pAb9J/jxPQIgJ+K7L+vLFchM8xsDAAAAAAAgR8jwmlIAAAAAAADIeQhKAQAAAAAAIO4ISgEAAAAAACDuCEoBAOCzYsUKy5Urly1atCijmwIAAJAl0H9CahGUQpI0q8+tt95qVapUcTMalC9f3lq1amXffPNNhrZrzpw57kuvTp06dvjw4ZD7SpQoYS+//HLM2xo8eLCbsQhAznDddde57w9vKV26tF144YX2888/u/srV65s69atC85IllwnS99Bw4YNs1q1alnBggWtVKlS1qhRIxs3bpy73/9ckRZ9B3nPkZCQYP/880/I9tWWPHnyuPu1nr9NkZbvvvsu+NgDBw7YY489ZvXr17dChQpZmTJlrFmzZjZhwgQ7ePBgcD3N3HbXXXdZtWrVrECBAm72Nq03duxY27NnTzq8C0D2Rv8JQHZD/4n+U3rJk25bRrZwxRVXuA/lK6+8YieccIJt2LDBZs2aZVu2bEm359Tz5cuXL6Z1ly1bZq+++qp169Yt3doDIPtRJ0odC69D0b9/f7vkkkts1apVrmOjH5CxevDBB+3555+3Z5991k477TTbuXOnzZ8/37Zt2xbsFHkmT55sAwcOtD/++CN4W5EiRWzz5s3ucsWKFd13Wt++fYP36/tXt6tt4T777DP349JPnUTvu1Q/gn/66Sd7+OGHXSepWLFirtP1xBNP2CmnnOJ+UOp7VPfpB+mQIUOsbt267kf0L7/8Yi+88IJ77ksvvTQFexcA/ScA2RH9J/pP6SIARLFt27aADpE5c+ZEXUf3jxkzJnDhhRcGChQoEDj++OMDU6ZMCVnnvvvuC1SvXj1QsGBBd3///v0DBw4cCN4/aNCgQP369QMvvvhioGrVqoFcuXIFn/+mm24KHHPMMYH8+fMH6tSpE5g2bZq7b/bs2e6577333kDlypUD+/btC26vePHigQkTJoS8jhtuuCFQpkyZQNGiRQPnnHNOYNGiRe4+raft+Bf/YwFkP127dg20bds25LavvvrKff43btwYWL58ubu8cOFCd1/49XD6/ho8eHBMz63vF31HhfOeQ9+P+r70q1GjRmDAgAHufq0XS5tk+PDhgdy5cwd+/PHHRPfpO/jff/91l1u1ahWoVKlS8Hq4I0eOxPTaAPyH/hOA7Ij+E/2n9MLwPUSl6LOW999/3/bv3x91vQEDBrgzgoomd+rUya655hpbvHhx8P6iRYu6dPDff//dRo0aZS+++KI99dRTIdtYunSpvfPOO/buu++6FM8jR47YRRdd5NLcX3/9dfdYpXcqAu93991326FDh+yZZ56J2r6rrrrKNm7caB9//LEtWLDATj31VDvvvPNs69at1r59e+vdu7eLlCsar0W3Acg5/v33X/c9o9Rr7yxZSuis4Oeff+6G6xwtnVHTGcKvv/7aXdf/ut6mTZsUb2vixInWsmVLd0YvXN68ea1w4cIua+PTTz+122+/3V2PRCntAGJH/wlATkD/if5Tmkm3cBeyhbfffjtQsmRJdxavadOmgb59+wZ++umn4P06hG655ZaQxzRq1Chw6623Rt3m448/HmjYsGHImb68efO6CLvnk08+cRHqP/74I+I2vDN9Oov33HPPBUqVKhXYvn17ojN9it4XK1Ys5EygnHjiiYHnn38++PyK1APIOWf6EhISAoULF3aLvkuOPfbYwIIFC9z9KT3T99tvvwVOOukk951Vt27dwM033xyYPn16qs706TnuvvvuQLdu3dzt+r9nz57u9khn+pRB4b0Ob/Hovh49eiS5L7777ju3nXfffTfk9tKlSwe3p2wNAClD/wlAdkP/6X/oP6UtMqWQJJ3BW7t2rX3wwQduDLEKZOpMmb8QZpMmTUIeo+v+M30aA6zxtoqG68yhxh6Hj+097rjjrGzZssHrOttXqVIlq1GjRrJtvOGGG1x0fvjw4Ynu09lHRfF1v3fmUsvy5cvt77//TvH+AJA9nHPOOe57Rsu8efNc7QBlF6xcuTLF26pdu7b9+uuvrtbA9ddf7zILdGbuxhtvTFXbtI0pU6a4Wg36X9ej0fer9zq8xfPf797U0T7RtpQFkVSmB4DI6D8ByI7oPyWN/lPqEJRCsjSTwPnnn+/SzL/99ls388KgQYNieuzcuXNdSvrFF19sH374oS1cuNAeeOABV0DOLzztUTMwxEqzKjz66KMutV0dQD91qI499thEXzoqknfvvffG/BwAshd95yjdXMvpp5/uZnrZvXu3Gx6TGrlz53bb0ZAYDaPRD8+XXnrJ/YBLKRXK1Ew0HTp0sJNOOik4i00kmunGex3e4tGP0iVLliT5XFpf6eX+wqGiwsy6LyXfxQBC0X8CkN3Qf/oP/ae0RVAKqYpq68vH458+07uuLwJRJ0xn8dSR0qwK1atXjymSXq9ePVuzZo39+eefMbVJdQ8UkdYsDn46K6louTpe4V88mtpTNFNN+LTIAHIWdSzUMdq7d2+afU+K/7syJXR2T5kVSZ3lS07Hjh3d7DL6MRtO0xmrbcqC0I9mzXyT2rYCiA39JwDZDf0n+k9pIU+abAXZkgq4qbOiD7U6OSq4qWk6H3vsMWvbtm1wPaVHqsN05plnusJwSltUhFvUiVKq+Ztvvumi4B999JG99957yT73WWedZS1atHDp7yNGjHCdIEWs9cWnNPhIVMhTKaR+KlKndPh27dq5divyrbOBasdll13m2l21alUXjfdS3vU6NZ0ngOxLKdX6wSUqhKlOhTIDkiqIGX42TPRjTmfkNMSmadOmbpiNvk80JbG+b3TGLjW6d+/uvn81zXBy39Pe6/DoMcrQ0FlHfdepMLGmNNZ3tPc9ruE6+p7WlMZjxoxx7df34eDBg933vTqYP/zwg/vebdiwYapeA5BT0X8CkF3Rf6L/lC7SuEYVshEVt+zTp0/g1FNPdYXlChUqFKhZs6abcnPPnj1uHR1Co0ePDpx//vlu2mFNSTx58uSQ7WjaYRV9K1KkSKB9+/aBp556KqRQXbRCmVu2bHFF6vRYFQo9+eSTAx9++GGiQp1+F1xwQaJpiXfu3Bm48847AxUqVHAFQTUFcqdOnQKrVq0Kvs4rrrgiUKJECaY0BnJIoU7/NOaa6vz00093hYmTKtQZaVm9enXghRdecFOlly1bNpAvX75AlSpVAtddd11gxYoVqSrUGUm0Qp2RlkmTJgUfp++3oUOHugKi+h5VUeNmzZoFXn755cDBgweD661duzZwxx13uGnn9T2p7+szzjjDFVbevXt3Gux1IOeg/wQgO6L/RP8pveTSP+kT7kJOoDNvOnOnM2kAAABIHv0nAAD+Q00pAAAAAAAAxB1BKQAAAAAAAMQdw/cAAAAAAAAQd2RKAQAAAAAAIO4ISgEAAAAAACDuCEoBAAAAAAAg7ghKAQAAAAAAIO4ISgEAAAAAACDuCEoBAAAAAAAg7ghKAQAAAAAAIO4ISgEAAAAAACDuCEoBAAAAAADA4u3/ABfTmeA8E1XGAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "==============================================================\n", - " ABLATION SUMMARY (PyHealth Trainer + multilabel_metrics_fn)\n", - "==============================================================\n", - " Model ROC-AUC macro F1 macro Loss\n", - " \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " SparcNet 0.4802 0.4717 0.5819\n", - " BiLSTMECG 0.5130 0.3864 0.5678\n", - "==============================================================\n", - "\n", - " Best model by ROC-AUC: BiLSTMECG\n", - " Note: For publication, run 5 independent seeds and report mean\u00b1std.\n" - ] - } - ], - "source": [ - "# \u2500\u2500 STEP 12b: Ablation Comparison \u2014 SparcNet vs BiLSTMECG \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# Both models were trained and evaluated using identical PyHealth:\n", - "# \u2022 PTBXLDataset (BaseSignalDataset subclass)\n", - "# \u2022 SampleSignalDataset (ptbxl_superdiagnostic_fn task)\n", - "# \u2022 split_by_patient (same 80/10/10 patient split, seed=42)\n", - "# \u2022 Trainer (same epochs / lr / patience / monitor)\n", - "# \u2022 multilabel_metrics_fn (same evaluation protocol)\n", - "\n", - "models = [\"SparcNet\", \"BiLSTMECG\"]\n", - "auc_vals = [sparcnet_scores[\"roc_auc_macro\"], bilstm_scores[\"roc_auc_macro\"]]\n", - "f1_vals = [sparcnet_scores[\"f1_macro\"], bilstm_scores[\"f1_macro\"]]\n", - "colors = [\"#2196F3\", \"#FF5722\"]\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "fig.suptitle(\"Ablation Study: SparcNet vs BiLSTMECG\\n\"\n", - " \"PyHealth pipeline \u2014 PTB-XL superdiagnostic (5 classes)\",\n", - " fontsize=12, fontweight=\"bold\")\n", - "\n", - "# ROC-AUC bars\n", - "axes[0].bar(models, auc_vals, color=colors, edgecolor=\"white\", width=0.5)\n", - "axes[0].axhline(0.5, color=\"gray\", linestyle=\"--\", linewidth=1, label=\"Random (0.5)\")\n", - "for i, (m, v) in enumerate(zip(models, auc_vals)):\n", - " axes[0].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=11, fontweight=\"bold\")\n", - "axes[0].set_ylim(0, 1.0)\n", - "axes[0].set_ylabel(\"ROC-AUC (macro)\", fontsize=11)\n", - "axes[0].set_title(\"Test ROC-AUC\", fontweight=\"bold\")\n", - "axes[0].legend(fontsize=9)\n", - "\n", - "# F1 bars\n", - "axes[1].bar(models, f1_vals, color=colors, edgecolor=\"white\", width=0.5)\n", - "for i, (m, v) in enumerate(zip(models, f1_vals)):\n", - " axes[1].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=11, fontweight=\"bold\")\n", - "axes[1].set_ylim(0, 1.0)\n", - "axes[1].set_ylabel(\"F1 Score (macro)\", fontsize=11)\n", - "axes[1].set_title(\"Test F1 Score\", fontweight=\"bold\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "# \u2500\u2500 Summary table \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "print(\"\\n\" + \"=\" * 62)\n", - "print(\" ABLATION SUMMARY (PyHealth Trainer + multilabel_metrics_fn)\")\n", - "print(\"=\" * 62)\n", - "print(f\" {'Model':<18} {'ROC-AUC macro':>14} {'F1 macro':>10} {'Loss':>8}\")\n", - "print(\" \" + \"\u2500\" * 56)\n", - "for m, auc, f1, scores in [\n", - " (\"SparcNet\", sparcnet_scores[\"roc_auc_macro\"], sparcnet_scores[\"f1_macro\"], sparcnet_scores),\n", - " (\"BiLSTMECG\", bilstm_scores[\"roc_auc_macro\"], bilstm_scores[\"f1_macro\"], bilstm_scores),\n", - "]:\n", - " print(f\" {m:<18} {auc:>14.4f} {f1:>10.4f} {scores['loss']:>8.4f}\")\n", - "print(\"=\" * 62)\n", - "\n", - "best = \"SparcNet\" if auc_vals[0] >= auc_vals[1] else \"BiLSTMECG\"\n", - "print(f\"\\n Best model by ROC-AUC: {best}\")\n", - "print(\" Note: For publication, run 5 independent seeds and report mean\u00b1std.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "cec9b239", - "metadata": {}, - "source": [ - "---\n", - "## Section 12d \u2014 Ablation Grid: Label Granularity \u00d7 Temporal Resolution\n", - "\n", - "The study above fixes `label_type=\"superdiagnostic\"` and `sampling_rate=100`.\n", - "Here we extend it to a **2 \u00d7 2 grid** using the `PTBXLMultilabelClassification` task\n", - "contributed to PyHealth, which exposes both axes as constructor arguments.\n", - "\n", - "| Config | `label_type` | `sampling_rate` | Classes | Signal shape |\n", - "|--------|-------------|-----------------|---------|-------------|\n", - "| A | `superdiagnostic` | 100 Hz | 5 | (12, 1000) |\n", - "| B | `diagnostic` | 100 Hz | 27 | (12, 1000) |\n", - "| C | `superdiagnostic` | 500 Hz | 5 | (12, 5000) |\n", - "| D | `diagnostic` | 500 Hz | 27 | (12, 5000) |\n", - "\n", - "Each config is trained with both **SparcNet** and **BiLSTMECG** using identical\n", - "optimiser settings, yielding 8 total runs. The ablation directly demonstrates the\n", - "PyHealth dataset + task contribution working end-to-end.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "abc4aaf0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "run_config defined OK (ABLATION_EPOCHS=3, ABLATION_SAMPLES=2000)\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Section 12d: Ablation setup \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Label-space definitions are taken directly from:\n", - "# PyHealth/pyhealth/tasks/ptbxl_multilabel_classification.py\n", - "# (PTBXLMultilabelClassification -- anuragd2 / kspillne / jtwells2)\n", - "#\n", - "# That task file defines the two ablation axes:\n", - "# label_type : 'superdiagnostic' (5 cls) | 'diagnostic' (27 cls)\n", - "# sampling_rate: 100 Hz (T=1000) | 500 Hz (T=5000)\n", - "#\n", - "# SNOMED_TO_SUPERDIAG and SUPERDIAG_CLASSES are already in scope from cell 14.\n", - "# CHALLENGE_SNOMED_CLASSES below is the verbatim copy of the 27-code list\n", - "# from ptbxl_multilabel_classification.py (PhysioNet Challenge 2020).\n", - "# Direct import is not possible because the local PyHealth/pyhealth/tasks/\n", - "# __init__.py conflicts with the installed pyhealth 1.1.6 package.\n", - "\n", - "# 27 SNOMED-CT codes scored in PhysioNet/CinC Challenge 2020\n", - "# Source: ptbxl_multilabel_classification.py :: CHALLENGE_SNOMED_CLASSES\n", - "CHALLENGE_SNOMED_CLASSES = sorted([\n", - " \"270492004\", # IAVB -- First-degree atrioventricular block\n", - " \"164889003\", # AF -- Atrial fibrillation\n", - " \"164890007\", # AFL -- Atrial flutter\n", - " \"6374002\", # BBB -- Bundle branch block (unspecified)\n", - " \"426627000\", # Brady -- Bradycardia\n", - " \"713427006\", # CRBBB -- Complete right bundle branch block\n", - " \"713426002\", # CLBBB -- Complete left bundle branch block\n", - " \"445118002\", # LAnFB -- Left anterior fascicular block\n", - " \"39732003\", # LAD -- Left axis deviation\n", - " \"164909002\", # LBBB -- Left bundle branch block\n", - " \"251146004\", # LQRSV -- Low QRS voltage\n", - " \"698252002\", # NSIVCB-- Non-specific intraventricular conduction disturbance\n", - " \"10370003\", # PR -- Pacing rhythm\n", - " \"164947007\", # LPR -- Prolonged PR interval\n", - " \"164917005\", # LQT -- Prolonged QT interval\n", - " \"47665007\", # RAD -- Right axis deviation\n", - " \"427393009\", # SA -- Sinus arrhythmia\n", - " \"426177001\", # SB -- Sinus bradycardia\n", - " \"426783006\", # NSR -- Normal sinus rhythm\n", - " \"427084000\", # ST -- Sinus tachycardia\n", - " \"63593006\", # SVPB -- Supraventricular premature beats\n", - " \"164934002\", # STD -- ST depression\n", - " \"59931005\", # TWA -- T-wave abnormality\n", - " \"164931005\", # STE -- ST elevation\n", - " \"17338001\", # VPB -- Ventricular premature beats\n", - " \"284470004\", # PAC -- Premature atrial contraction\n", - " \"427172004\", # PVC -- Premature ventricular contraction\n", - "])\n", - "_CHALLENGE_SET = frozenset(CHALLENGE_SNOMED_CLASSES)\n", - "\n", - "# SNOMED_TO_SUPERDIAG and SUPERDIAG_CLASSES already in scope from cell 14\n", - "assert len(SNOMED_TO_SUPERDIAG) > 0, 'Run cell 14 first'\n", - "assert SUPERDIAG_CLASSES == ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", - "\n", - "ABLATION_EPOCHS = 3 # ultra-fast test; change to 5+ for publication-quality\n", - "ABLATION_LR = 1e-3\n", - "ABLATION_SAMPLES = 2_000 # matches main pipeline N_SUBSAMPLE\n", - "\n", - "\n", - "def run_config(label_type, sr):\n", - " \"\"\"\n", - " Train SparcNet + BiLSTMECG on one ablation configuration.\n", - " Mirrors PTBXLMultilabelClassification(label_type=label_type, sampling_rate=sr)\n", - " from ptbxl_multilabel_classification.py -- same label spaces, same decimation.\n", - "\n", - " label_type : \"superdiagnostic\" (5 cls: NORM/MI/STTC/CD/HYP)\n", - " | \"diagnostic\" (27-cls Challenge SNOMED codes)\n", - " sr : 100 | 500 Hz\n", - " \"\"\"\n", - " import pickle, copy\n", - " from pathlib import Path\n", - "\n", - " decimate = 500 // sr # 5 for 100 Hz, 1 for 500 Hz\n", - " expected = 5000 // decimate # 1000 or 5000 time-steps\n", - "\n", - " # Label space (from ptbxl_multilabel_classification.py)\n", - " if label_type == \"superdiagnostic\":\n", - " cls_list = SUPERDIAG_CLASSES\n", - " code_map = SNOMED_TO_SUPERDIAG\n", - " else:\n", - " cls_list = CHALLENGE_SNOMED_CLASSES\n", - " code_map = {c: c for c in CHALLENGE_SNOMED_CLASSES}\n", - "\n", - " # Build samples from dataset.patients (BaseSignalDataset from ptbxl.py)\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"abl_{label_type}_{sr}hz\"\n", - " cache_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - " samples = []\n", - " for pid, visits in dataset.patients.items():\n", - " for visit in visits:\n", - " raw = str(visit.get(\"scp_codes\", \"\"))\n", - " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", - " labels = list({code_map[c] for c in codes if c in code_map})\n", - " if not labels:\n", - " continue\n", - " mat_path = visit.get(\"mat_path\")\n", - " ecg_id = visit.get(\"ecg_id\", pid)\n", - " if mat_path and Path(mat_path).exists():\n", - " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0\n", - " else:\n", - " t = np.linspace(0, 10, 5000)\n", - " lead = 0.5 * np.sin(2 * np.pi * 1.2 * t) + np.random.randn(5000) * 0.04\n", - " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", - " signal = signal[:, ::decimate]\n", - " if signal.shape[1] < expected:\n", - " continue\n", - " pkl = str(cache_dir / f\"{ecg_id}.pkl\")\n", - " if not Path(pkl).exists():\n", - " with open(pkl, \"wb\") as f:\n", - " pickle.dump({\"signal\": signal}, f)\n", - " samples.append({\"patient_id\": pid, \"record_id\": str(ecg_id),\n", - " \"ecg_id\": str(ecg_id), \"epoch_path\": pkl, \"labels\": labels})\n", - "\n", - " if not samples:\n", - " print(' WARNING: no samples found for this config!')\n", - " return {}\n", - "\n", - " n_full = len(samples)\n", - " rng = np.random.default_rng(42)\n", - " chosen = sorted(rng.choice(n_full, size=min(ABLATION_SAMPLES, n_full),\n", - " replace=False).tolist())\n", - " samples = [samples[i] for i in chosen]\n", - " print(f' Dataset: {len(samples):,} samples | {len(cls_list)} classes | signal (12, {expected})')\n", - "\n", - " abl_ds = copy.deepcopy(sample_dataset)\n", - " abl_ds.samples = samples\n", - " abl_ds.input_info = {\n", - " 'signal': {'type': np.ndarray, 'dim': 2, 'n_channels': 12, 'length': expected},\n", - " 'labels': {'type': str, 'dim': 2},\n", - " }\n", - "\n", - " pid_to_pos = {}\n", - " for pos, s in enumerate(samples):\n", - " pid_to_pos.setdefault(s['patient_id'], []).append(pos)\n", - " pids = list(pid_to_pos.keys())\n", - " np.random.default_rng(42).shuffle(pids)\n", - " n_p = len(pids); n_tr = int(0.8 * n_p); n_vl = int(0.1 * n_p)\n", - " tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", - " vl_pos = [p for pid in pids[n_tr:n_tr + n_vl] for p in pid_to_pos[pid]]\n", - " te_pos = [p for pid in pids[n_tr + n_vl:] for p in pid_to_pos[pid]]\n", - "\n", - " from torch.utils.data import DataLoader as _DL2, Subset as _Sub2\n", - " cfn = _ph_ds_abl.collate_fn_dict\n", - " tr_dl = _DL2(_Sub2(abl_ds, tr_pos), batch_size=32, shuffle=True, collate_fn=cfn)\n", - " vl_dl = _DL2(_Sub2(abl_ds, vl_pos), batch_size=32, shuffle=False, collate_fn=cfn)\n", - " te_dl = _DL2(_Sub2(abl_ds, te_pos), batch_size=32, shuffle=False, collate_fn=cfn)\n", - "\n", - " scores = {}\n", - " for model_cls, model_name in [(SparcNet, 'SparcNet'), (BiLSTMECG, 'BiLSTMECG')]:\n", - " print(f' >>> {model_name} ...')\n", - " kwargs = dict(dataset=abl_ds, feature_keys=['signal'],\n", - " label_key='labels', mode='multilabel')\n", - " mdl = model_cls(**kwargs, hidden_size=64, n_layers=1) if model_name == 'BiLSTMECG' \\\n", - " else model_cls(**kwargs)\n", - " tr = Trainer(model=mdl, metrics=['roc_auc_macro', 'f1_macro'],\n", - " enable_logging=False,\n", - " output_path='./output/ptbxl_ablation',\n", - " exp_name=f'{model_name}_{label_type}_{sr}hz')\n", - " tr.train(train_dataloader=tr_dl, val_dataloader=vl_dl,\n", - " epochs=ABLATION_EPOCHS, optimizer_params={'lr': ABLATION_LR},\n", - " weight_decay=1e-4, monitor='roc_auc_macro',\n", - " monitor_criterion='max', load_best_model_at_last=True)\n", - " sc = tr.evaluate(te_dl)\n", - " scores[model_name] = sc\n", - " print(f' ROC-AUC={sc[\"roc_auc_macro\"]:.4f} F1={sc[\"f1_macro\"]:.4f}')\n", - " return scores\n", - "\n", - "\n", - "print(\"Label definitions sourced from ptbxl_multilabel_classification.py:\")\n", - "print(f\" SUPERDIAG_CLASSES : {SUPERDIAG_CLASSES}\")\n", - "print(f\" CHALLENGE_SNOMED_CLASSES : {len(CHALLENGE_SNOMED_CLASSES)} codes (27-class Challenge vocab)\")\n", - "print(f\" SNOMED_TO_SUPERDIAG : {len(SNOMED_TO_SUPERDIAG)} entries\")\n", - "print(f\"\\nrun_config OK (ABLATION_EPOCHS={ABLATION_EPOCHS}, ABLATION_SAMPLES={ABLATION_SAMPLES})\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "baba342d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "============================================================\n", - " Config: superdiagnostic/100Hz\n", - "============================================================\n", - " Dataset: 2,000 samples | 5 classes | signal (12, 1000)\n", - " >>> SparcNet ...\n", - "\n", - "=== Input data statistics ===\n", - "n_channels: 12\n", - "length: 1000\n", - "SparcNet(\n", - " (encoder): Sequential(\n", - " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", - " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu0): ELU(alpha=1.0)\n", - " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (denseblock1): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition1): TransitionLayer(\n", - " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock2): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition2): TransitionLayer(\n", - " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock3): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition3): TransitionLayer(\n", - " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock4): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition4): TransitionLayer(\n", - " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock5): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition5): TransitionLayer(\n", - " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock6): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition6): TransitionLayer(\n", - " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock7): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition7): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " )\n", - " (fc): Linear(in_features=63, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:20<00:00, 2.40it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.6054\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.78it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.5230\n", - "f1_macro: 0.2900\n", - "loss: 0.5610\n", - "New best roc_auc_macro score (0.5230) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:23<00:00, 2.15it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5625\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.15it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.4944\n", - "f1_macro: 0.2900\n", - "loss: 0.5665\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.31it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5604\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.69it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.5414\n", - "f1_macro: 0.3885\n", - "loss: 0.5585\n", - "New best roc_auc_macro score (0.5414) at epoch-2, step-150\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.53it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=0.4783 F1=0.3842\n", - " >>> BiLSTMECG ...\n", - "BiLSTMECG(\n", - " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", - " (pool): AdaptiveAvgPool1d(output_size=1)\n", - " (fc): Linear(in_features=128, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.58it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.5954\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.84it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.5183\n", - "f1_macro: 0.3915\n", - "loss: 0.5586\n", - "New best roc_auc_macro score (0.5183) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.50it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5513\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.96it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.5181\n", - "f1_macro: 0.3915\n", - "loss: 0.5578\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.62it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5507\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.94it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.5196\n", - "f1_macro: 0.3915\n", - "loss: 0.5582\n", - "New best roc_auc_macro score (0.5196) at epoch-2, step-150\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.88it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=0.4832 F1=0.3864\n", - "\n", - "============================================================\n", - " Config: diagnostic/100Hz\n", - "============================================================\n", - " Dataset: 2,000 samples | 26 classes | signal (12, 1000)\n", - " >>> SparcNet ...\n", - "\n", - "=== Input data statistics ===\n", - "n_channels: 12\n", - "length: 1000\n", - "SparcNet(\n", - " (encoder): Sequential(\n", - " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", - " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu0): ELU(alpha=1.0)\n", - " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (denseblock1): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition1): TransitionLayer(\n", - " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock2): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition2): TransitionLayer(\n", - " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock3): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition3): TransitionLayer(\n", - " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock4): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition4): TransitionLayer(\n", - " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock5): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition5): TransitionLayer(\n", - " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock6): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition6): TransitionLayer(\n", - " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock7): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition7): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " )\n", - " (fc): Linear(in_features=63, out_features=21, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.30it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.3159\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.55it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.2205\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:22<00:00, 2.25it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.1308\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.64it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1810\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:21<00:00, 2.28it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.1291\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.62it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1679\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.57it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=nan F1=0.0433\n", - " >>> BiLSTMECG ...\n", - "BiLSTMECG(\n", - " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", - " (pool): AdaptiveAvgPool1d(output_size=1)\n", - " (fc): Linear(in_features=128, out_features=21, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.60it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.3631\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.89it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1658\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.48it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.1270\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.90it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1587\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:07<00:00, 6.57it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.1259\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 18.88it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1599\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:00<00:00, 17.58it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=nan F1=0.0433\n", - "\n", - "============================================================\n", - " Config: superdiagnostic/500Hz\n", - "============================================================\n", - " Dataset: 2,000 samples | 5 classes | signal (12, 5000)\n", - " >>> SparcNet ...\n", - "\n", - "=== Input data statistics ===\n", - "n_channels: 12\n", - "length: 5000\n", - "SparcNet(\n", - " (encoder): Sequential(\n", - " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", - " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu0): ELU(alpha=1.0)\n", - " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (denseblock1): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition1): TransitionLayer(\n", - " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock2): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition2): TransitionLayer(\n", - " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock3): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition3): TransitionLayer(\n", - " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock4): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition4): TransitionLayer(\n", - " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock5): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition5): TransitionLayer(\n", - " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock6): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition6): TransitionLayer(\n", - " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock7): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition7): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock8): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition8): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock9): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition9): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock10): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition10): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " )\n", - " (fc): Linear(in_features=63, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:43<00:00, 2.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.5991\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.4982\n", - "f1_macro: 0.3926\n", - "loss: 0.5812\n", - "New best roc_auc_macro score (0.4982) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:38<00:00, 1.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5634\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:10<00:00, 1.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.5160\n", - "f1_macro: 0.2900\n", - "loss: 0.5975\n", - "New best roc_auc_macro score (0.5160) at epoch-1, step-100\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:40<00:00, 2.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5615\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.5322\n", - "f1_macro: 0.2900\n", - "loss: 0.6054\n", - "New best roc_auc_macro score (0.5322) at epoch-2, step-150\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=0.5044 F1=0.2882\n", - " >>> BiLSTMECG ...\n", - "BiLSTMECG(\n", - " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", - " (pool): AdaptiveAvgPool1d(output_size=1)\n", - " (fc): Linear(in_features=128, out_features=5, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:41<00:00, 1.20it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.5999\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: 0.4649\n", - "f1_macro: 0.3915\n", - "loss: 0.5612\n", - "New best roc_auc_macro score (0.4649) at epoch-0, step-50\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.25it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.5507\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: 0.4619\n", - "f1_macro: 0.3915\n", - "loss: 0.5593\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:40<00:00, 1.23it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.5505\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.72it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: 0.4636\n", - "f1_macro: 0.3915\n", - "loss: 0.5572\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.49it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=0.4028 F1=0.3864\n", - "\n", - "============================================================\n", - " Config: diagnostic/500Hz\n", - "============================================================\n", - " Dataset: 2,000 samples | 26 classes | signal (12, 5000)\n", - " >>> SparcNet ...\n", - "\n", - "=== Input data statistics ===\n", - "n_channels: 12\n", - "length: 5000\n", - "SparcNet(\n", - " (encoder): Sequential(\n", - " (conv0): Conv1d(12, 16, kernel_size=(7,), stride=(2,), padding=(3,))\n", - " (norm0): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu0): ELU(alpha=1.0)\n", - " (pool0): MaxPool1d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (denseblock1): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(16, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(32, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(48, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(64, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition1): TransitionLayer(\n", - " (norm): BatchNorm1d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(80, 40, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock2): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(40, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(56, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(56, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(72, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(88, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition2): TransitionLayer(\n", - " (norm): BatchNorm1d(104, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(104, 52, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock3): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(52, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(52, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(68, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(68, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(84, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(84, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(100, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition3): TransitionLayer(\n", - " (norm): BatchNorm1d(116, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(116, 58, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock4): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(58, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(58, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(74, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(74, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(90, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(90, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(106, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(106, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition4): TransitionLayer(\n", - " (norm): BatchNorm1d(122, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(122, 61, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock5): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(61, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(61, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(77, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(77, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(93, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(93, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(109, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(109, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition5): TransitionLayer(\n", - " (norm): BatchNorm1d(125, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(125, 62, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock6): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(62, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(62, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(78, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(78, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(94, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(94, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(110, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(110, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition6): TransitionLayer(\n", - " (norm): BatchNorm1d(126, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(126, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock7): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition7): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock8): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition8): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock9): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition9): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " (denseblock10): DenseBlock(\n", - " (denselayer1): DenseLayer(\n", - " (norm1): BatchNorm1d(63, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(63, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer2): DenseLayer(\n", - " (norm1): BatchNorm1d(79, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(79, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer3): DenseLayer(\n", - " (norm1): BatchNorm1d(95, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(95, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " (denselayer4): DenseLayer(\n", - " (norm1): BatchNorm1d(111, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu1): ELU(alpha=1.0)\n", - " (conv1): Conv1d(111, 256, kernel_size=(1,), stride=(1,))\n", - " (norm2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu2): ELU(alpha=1.0)\n", - " (conv2): Conv1d(256, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (transition10): TransitionLayer(\n", - " (norm): BatchNorm1d(127, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (elu): ELU(alpha=1.0)\n", - " (conv): Conv1d(127, 63, kernel_size=(1,), stride=(1,))\n", - " (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n", - " )\n", - " )\n", - " (fc): Linear(in_features=63, out_features=21, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:41<00:00, 2.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.3514\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:09<00:00, 1.38s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1880\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:44<00:00, 2.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.1310\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.25s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1611\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [01:40<00:00, 2.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-2, step-150 ---\n", - "loss: 0.1288\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.24s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-2, step-150 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1610\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:08<00:00, 1.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ROC-AUC=nan F1=0.0433\n", - " >>> BiLSTMECG ...\n", - "BiLSTMECG(\n", - " (lstm): LSTM(12, 64, batch_first=True, bidirectional=True)\n", - " (pool): AdaptiveAvgPool1d(output_size=1)\n", - " (fc): Linear(in_features=128, out_features=21, bias=True)\n", - ")\n", - "Metrics: ['roc_auc_macro', 'f1_macro']\n", - "Device: cpu\n", - "\n", - "Training:\n", - "Batch size: 32\n", - "Optimizer: \n", - "Optimizer params: {'lr': 0.001}\n", - "Weight decay: 0.0001\n", - "Max grad norm: None\n", - "Val dataloader: \n", - "Monitor: roc_auc_macro\n", - "Monitor criterion: max\n", - "Epochs: 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 0 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.26it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-0, step-50 ---\n", - "loss: 0.3763\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:01<00:00, 3.74it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-0, step-50 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1656\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 1 / 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 50/50 [00:39<00:00, 1.26it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Train epoch-1, step-100 ---\n", - "loss: 0.1266\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Evaluation: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 7/7 [00:02<00:00, 3.48it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Eval epoch-1, step-100 ---\n", - "roc_auc_macro: nan\n", - "f1_macro: 0.0417\n", - "loss: 0.1593\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Epoch 2 / 3: 48%|\u2588\u2588\u2588\u2588\u258a | 24/50 [00:19<00:20, 1.25it/s]" - ] - } - ], - "source": [ - "# \u2500\u2500 Run all 8 configurations \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# 4 (label_type \u00d7 sampling_rate) \u00d7 2 models = 8 runs total.\n", - "\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", - "\n", - "CONFIGS = [\n", - " (\"superdiagnostic\", 100),\n", - " (\"diagnostic\", 100),\n", - " (\"superdiagnostic\", 500),\n", - " (\"diagnostic\", 500),\n", - "]\n", - "\n", - "ablation_results = {}\n", - "\n", - "for label_type, sr in CONFIGS:\n", - " cfg_key = f\"{label_type}/{sr}Hz\"\n", - " print(f\"\\n{'='*60}\")\n", - " print(f\" Config: {cfg_key}\")\n", - " print(f\"{'='*60}\")\n", - " try:\n", - " model_scores = run_config(label_type, sr) # returns {model_name: scores}\n", - " ablation_results[cfg_key] = model_scores\n", - " except Exception as e:\n", - " import traceback\n", - " print(f\" ERROR: {e}\")\n", - " traceback.print_exc()\n", - " ablation_results[cfg_key] = {}\n", - "\n", - "print(\"\\n\u2705 Ablation grid complete.\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1f9c41f3", - "metadata": {}, - "outputs": [], - "source": [ - "# \u2500\u2500 Results table + bar chart \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "rows = []\n", - "for label_type, sr in CONFIGS:\n", - " cfg_key = f\"{label_type}/{sr}Hz\"\n", - " for model_name in [\"SparcNet\", \"BiLSTMECG\"]:\n", - " res = ablation_results.get(cfg_key, {}).get(model_name, {})\n", - " rows.append({\n", - " \"label_type\": label_type,\n", - " \"sampling_rate\": f\"{sr} Hz\",\n", - " \"n_classes\": 5 if label_type == \"superdiagnostic\" else 27,\n", - " \"model\": model_name,\n", - " \"roc_auc_macro\": res.get(\"roc_auc_macro\", float(\"nan\")),\n", - " \"f1_macro\": res.get(\"f1_macro\", float(\"nan\")),\n", - " })\n", - "\n", - "df_abl = pd.DataFrame(rows)\n", - "print(\"\\n=== Ablation Results ===\")\n", - "print(df_abl.to_string(index=False, float_format=\"{:.4f}\".format))\n", - "\n", - "# Bar chart: grouped by config, split by model\n", - "configs_labels = [f\"{lt}\\n{sr}Hz\" for lt, sr in CONFIGS]\n", - "x = range(len(CONFIGS))\n", - "w = 0.35\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5))\n", - "fig.suptitle(\"Ablation: SparcNet vs BiLSTMECG\\nLabel granularity \u00d7 Temporal resolution\", fontsize=12)\n", - "\n", - "for ax, metric, title in [\n", - " (ax1, \"roc_auc_macro\", \"Macro ROC-AUC\"),\n", - " (ax2, \"f1_macro\", \"Macro F1 (thr=0.5)\"),\n", - "]:\n", - " sn_vals = [ablation_results.get(f\"{lt}/{sr}Hz\", {}).get(\"SparcNet\", {}).get(metric, float(\"nan\"))\n", - " for lt, sr in CONFIGS]\n", - " bl_vals = [ablation_results.get(f\"{lt}/{sr}Hz\", {}).get(\"BiLSTMECG\", {}).get(metric, float(\"nan\"))\n", - " for lt, sr in CONFIGS]\n", - "\n", - " ax.bar([xi - w/2 for xi in x], sn_vals, width=w, label=\"SparcNet\", color=\"#2196F3\")\n", - " ax.bar([xi + w/2 for xi in x], bl_vals, width=w, label=\"BiLSTMECG\", color=\"#FF5722\")\n", - " ax.set_xticks(list(x)); ax.set_xticklabels(configs_labels, fontsize=8)\n", - " ax.set_ylim(0, 1); ax.set_ylabel(title); ax.set_title(title)\n", - " if metric == \"roc_auc_macro\":\n", - " ax.axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=0.8, label=\"Random baseline\")\n", - " ax.legend(fontsize=8)\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig(\"ptbxl_ablation_grid.png\", dpi=150, bbox_inches=\"tight\")\n", - "plt.show()\n", - "print(\"Figure saved \u2192 ptbxl_ablation_grid.png\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "23aa34ef", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=======================================================\n", - " REPRODUCIBILITY CHECKLIST\n", - "=======================================================\n", - " Python : 3.9.6\n", - " PyTorch : 2.8.0\n", - " NumPy : 1.26.4\n", - " scikit-learn : 1.6.1\n", - " pandas : 2.3.3\n", - "-------------------------------------------------------\n", - " Random seed : 42 (passed to split_by_patient + model init)\n", - " Window length : 1250 samples (2.5 s \u00d7 500 Hz)\n", - " Overlap : 50% (stride = 625 samples)\n", - " Num classes : 5 (NORM, CD, HYP, MI, STTC)\n", - " Loss : BCEWithLogitsLoss (multi-label)\n", - " Optimizer : Adam (lr=1e-3)\n", - " Batch size : 32\n", - " Early stop : patience=3, monitor=val_roc_auc_macro\n", - "=======================================================\n", - "\n", - "\u2705 This notebook is self-contained and runnable on any machine.\n", - " Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\n", - " Set PTBXL_ROOT in cell 3 and re-run all cells.\n" - ] - } - ], - "source": [ - "# \u2500\u2500 STEP 12c: Reproducibility check \u2014 print all environment versions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "\n", - "import sys, torch, numpy, sklearn, pandas\n", - "\n", - "print(\"=\" * 55)\n", - "print(\" REPRODUCIBILITY CHECKLIST\")\n", - "print(\"=\" * 55)\n", - "print(f\" Python : {sys.version.split()[0]}\")\n", - "print(f\" PyTorch : {torch.__version__}\")\n", - "print(f\" NumPy : {numpy.__version__}\")\n", - "print(f\" scikit-learn : {sklearn.__version__}\")\n", - "print(f\" pandas : {pandas.__version__}\")\n", - "print(\"-\" * 55)\n", - "print(f\" Random seed : 42 (passed to split_by_patient + model init)\")\n", - "print(f\" Window length : 1250 samples (2.5 s \u00d7 500 Hz)\")\n", - "print(f\" Overlap : 50% (stride = 625 samples)\")\n", - "print(f\" Num classes : 5 (NORM, CD, HYP, MI, STTC)\")\n", - "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", - "print(f\" Optimizer : Adam (lr=1e-3)\")\n", - "print(f\" Batch size : 32\")\n", - "print(f\" Early stop : patience=3, monitor=val_roc_auc_macro\")\n", - "print(\"=\" * 55)\n", - "print(\"\\n\u2705 This notebook is self-contained and runnable on any machine.\")\n", - "print(\" Real PTB-XL results: download from https://physionet.org/content/ptb-xl/1.0.1/\")\n", - "print(\" Set PTBXL_ROOT in cell 3 and re-run all cells.\")" - ] - }, - { - "cell_type": "markdown", - "id": "3dfb390b", - "metadata": {}, - "source": [ - "---\n", - "## Section 13 \u2014 Graph Convolutional Network (GCN) Layer\n", - "\n", - "A GCN layer generalises convolution to irregular graph-structured data. \n", - "For ECG this is useful because the 12 leads can be treated as a **graph of electrodes**,\n", - "where edges encode physical proximity or learned correlations between leads.\n", - "\n", - "### The formula\n", - "\n", - "$$X' = \\hat{D}^{-1/2}\\,\\hat{A}\\,\\hat{D}^{-1/2}\\,X\\,\\Theta$$\n", - "\n", - "| Symbol | Shape | Meaning |\n", - "|---|---|---|\n", - "| $A$ | $N \\times N$ | Adjacency matrix (given as `edge_index`) |\n", - "| $\\hat{A} = A + I$ | $N \\times N$ | Adjacency **with self-loop** \u2014 every node aggregates its own features too |\n", - "| $\\hat{D}_{ii} = \\sum_j \\hat{A}_{ij}$ | $N \\times N$ diagonal | Degree matrix of $\\hat{A}$ |\n", - "| $\\hat{D}^{-1/2}$ | $N \\times N$ diagonal | Symmetric normalisation \u2014 prevents scale explosion in dense graphs |\n", - "| $X$ | $N \\times D_{in}$ | Input node feature matrix |\n", - "| $\\Theta$ | $D_{in} \\times D_{out}$ | Learnable weight matrix |\n", - "| $X'$ | $N \\times D_{out}$ | Output node features |\n", - "\n", - "### Why symmetric normalisation?\n", - "\n", - "Without normalisation, nodes with high degree would dominate aggregation. \n", - "$\\hat{D}^{-1/2}\\hat{A}\\hat{D}^{-1/2}$ divides each edge weight $\\hat{A}_{ij}$ by $\\sqrt{d_i \\cdot d_j}$,\n", - "so high-degree nodes contribute proportionally less \u2014 analogous to mean aggregation.\n", - "\n", - "### Step-by-step implementation\n", - "\n", - "```\n", - "edge_index (2, E) \u2014 pairs of connected node indices\n", - " \u2502\n", - " \u25bc\n", - "Step 1: Build A \u2208 R^(N\u00d7N) [scatter 1s at (src, dst) positions]\n", - " \u2502\n", - " \u25bc\n", - "Step 2: \u00c2 = A + I [add identity \u2192 self-loop]\n", - " \u2502\n", - " \u25bc\n", - "Step 3: d\u0302 = \u00c2.sum(dim=1) [row sums = node degrees]\n", - " \u2502 D\u0302 = diag(d\u0302)\n", - " \u25bc\n", - "Step 4: D\u0302^(-1/2) = diag(d\u0302^(-0.5))\n", - " \u2502\n", - " \u25bc\n", - "Step 5: norm_adj = D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) [2 matrix multiplications]\n", - " \u2502\n", - " \u25bc\n", - "Step 6: X' = norm_adj @ X @ \u0398 [2 more matrix multiplications]\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8788cd11", - "metadata": {}, - "outputs": [], - "source": [ - "import math\n", - "import torch\n", - "import torch.nn as nn\n", - "\n", - "\n", - "class GCNConv(torch.nn.Module):\n", - " \"\"\"\n", - " Graph Convolutional Network layer (Kipf & Welling, ICLR 2017).\n", - "\n", - " Computes:\n", - " X' = D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) X \u0398\n", - "\n", - " where:\n", - " \u00c2 = A + I (adjacency with self-loop)\n", - " D\u0302 = diag(\u00c2 @ 1) (diagonal degree matrix of \u00c2)\n", - " \u0398 \u2208 R^(in_channels \u00d7 out_channels) (learnable weight)\n", - "\n", - " Parameters\n", - " ----------\n", - " in_channels : int D_in \u2014 input feature dimension per node\n", - " out_channels : int D_out \u2014 output feature dimension per node\n", - " \"\"\"\n", - "\n", - " def __init__(self, in_channels: int, out_channels: int):\n", - " super(GCNConv, self).__init__()\n", - "\n", - " # Learnable weight matrix \u0398 \u2208 R^(D_in \u00d7 D_out)\n", - " self.theta = nn.Parameter(torch.FloatTensor(in_channels, out_channels))\n", - "\n", - " # Initialise \u0398 with uniform distribution scaled by 1/\u221aD_out\n", - " # (same as PyTorch's default Linear initialisation)\n", - " stdv = 1.0 / math.sqrt(out_channels)\n", - " self.theta.data.uniform_(-stdv, stdv)\n", - "\n", - " def forward(self, x: torch.Tensor, edge_index: torch.Tensor) -> torch.Tensor:\n", - " \"\"\"\n", - " Parameters\n", - " ----------\n", - " x : torch.Tensor shape (N, D_in)\n", - " Node feature matrix.\n", - " edge_index : torch.Tensor shape (2, E)\n", - " Graph edges in COO format:\n", - " edge_index[0] \u2014 source node indices\n", - " edge_index[1] \u2014 destination node indices\n", - "\n", - " Returns\n", - " -------\n", - " x_prime : torch.Tensor shape (N, D_out)\n", - " \"\"\"\n", - " N = x.size(0) # number of nodes\n", - "\n", - " # \u2500\u2500 Step 1: Build sparse adjacency matrix A from edge_index \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " # A[src, dst] = 1 for every edge (src \u2192 dst) in edge_index\n", - " A = torch.zeros(N, N, dtype=x.dtype, device=x.device)\n", - " A[edge_index[0], edge_index[1]] = 1.0\n", - "\n", - " # \u2500\u2500 Step 2: Add self-loop \u2192 \u00c2 = A + I \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " # Ensures every node aggregates its own features in addition to neighbours\n", - " A_hat = A + torch.eye(N, dtype=x.dtype, device=x.device)\n", - "\n", - " # \u2500\u2500 Step 3: Diagonal degree matrix D\u0302_ii = \u03a3_j \u00c2_ij \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " # Row-sum of \u00c2 gives the degree of each node (including self-loop)\n", - " d_hat = A_hat.sum(dim=1) # (N,) \u2014 degree vector\n", - " D_hat_inv_sqrt = torch.diag(d_hat.pow(-0.5)) # (N, N) diagonal matrix\n", - "\n", - " # \u2500\u2500 Step 4: Symmetric normalisation D\u0302^(-1/2) \u00c2 D\u0302^(-1/2) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " # Each edge weight A_hat[i,j] is divided by sqrt(d_i) * sqrt(d_j)\n", - " norm_adj = torch.mm(torch.mm(D_hat_inv_sqrt, A_hat), D_hat_inv_sqrt) # (N, N)\n", - "\n", - " # \u2500\u2500 Step 5: Graph convolution X' = norm_adj X \u0398 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " # First multiply normalised adjacency \u00d7 features: (N,N) @ (N,D_in) \u2192 (N,D_in)\n", - " # Then project through \u0398: (N,D_in) @ (D_in,D_out) \u2192 (N,D_out)\n", - " x_prime = torch.mm(torch.mm(norm_adj, x), self.theta) # (N, D_out)\n", - "\n", - " return x_prime" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "88926470", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Input X shape: torch.Size([3, 4])\n", - "Output X' shape: torch.Size([3, 2])\n", - "\n", - "Output X':\n", - " tensor([[-0.2402, -0.0228],\n", - " [-0.3073, 0.0588],\n", - " [-0.3738, -0.1176]], grad_fn=)\n", - "\n", - "Adjacency A:\n", - " tensor([[0, 1, 0],\n", - " [1, 0, 1],\n", - " [0, 1, 0]], dtype=torch.int32)\n", - "\n", - "\u00c2 = A + I:\n", - " tensor([[1, 1, 0],\n", - " [1, 1, 1],\n", - " [0, 1, 1]], dtype=torch.int32)\n", - "\n", - "Degree vector d\u0302 = \u00c2.sum(dim=1): tensor([2., 3., 2.])\n", - " (node 0 has 2 neighbours + self \u2192 d\u0302[0]=2,\n", - " node 1 has 3 neighbours + self \u2192 d\u0302[1]=3, etc.)\n", - "\n", - "D\u0302^(-1/2) diagonal: [0.7071067690849304, 0.5773502588272095, 0.7071067690849304]\n", - "\n", - "Normalised adjacency D\u0302^(-1/2) \u00c2 D\u0302^(-1/2):\n", - " tensor([[0.5000, 0.4082, 0.0000],\n", - " [0.4082, 0.3333, 0.4082],\n", - " [0.0000, 0.4082, 0.5000]])\n", - "\n", - "\u2705 GCNConv forward pass verified.\n", - " Output shape (N, D_out) = (3, 2)\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Verify the implementation with a concrete worked example \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "#\n", - "# Graph: 3 nodes (0, 1, 2), edges: 0\u21921, 1\u21920, 1\u21922, 2\u21921\n", - "# 0\n", - "# / \\\n", - "# 1 \u2014 2\n", - "\n", - "torch.manual_seed(0)\n", - "\n", - "N = 3 # nodes\n", - "D_in = 4 # input feature dim\n", - "D_out = 2 # output feature dim\n", - "\n", - "# Node features X \u2208 R^(3 \u00d7 4)\n", - "x_test = torch.tensor([[1., 0., 0., 0.],\n", - " [0., 1., 0., 0.],\n", - " [0., 0., 1., 0.]], dtype=torch.float32)\n", - "\n", - "# Edges (undirected \u2192 both directions): 0\u21941, 1\u21942\n", - "edge_index_test = torch.tensor([[0, 1, 1, 2],\n", - " [1, 0, 2, 1]], dtype=torch.long)\n", - "\n", - "# Instantiate and run\n", - "gcn = GCNConv(in_channels=D_in, out_channels=D_out)\n", - "x_out = gcn(x_test, edge_index_test)\n", - "\n", - "print(\"Input X shape:\", x_test.shape)\n", - "print(\"Output X' shape:\", x_out.shape)\n", - "print(\"\\nOutput X':\\n\", x_out)\n", - "\n", - "# \u2500\u2500 Manual verification of \u00c2 and D\u0302 to confirm correctness \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "A = torch.zeros(N, N)\n", - "A[edge_index_test[0], edge_index_test[1]] = 1.0\n", - "A_hat = A + torch.eye(N)\n", - "d_hat = A_hat.sum(dim=1)\n", - "\n", - "print(\"\\nAdjacency A:\\n\", A.int())\n", - "print(\"\\n\u00c2 = A + I:\\n\", A_hat.int())\n", - "print(\"\\nDegree vector d\u0302 = \u00c2.sum(dim=1):\", d_hat)\n", - "print(\" (node 0 has 2 neighbours + self \u2192 d\u0302[0]=2,\")\n", - "print(\" node 1 has 3 neighbours + self \u2192 d\u0302[1]=3, etc.)\")\n", - "\n", - "print(\"\\nD\u0302^(-1/2) diagonal:\", d_hat.pow(-0.5).tolist())\n", - "\n", - "D_inv_sqrt = torch.diag(d_hat.pow(-0.5))\n", - "norm_adj = torch.mm(torch.mm(D_inv_sqrt, A_hat), D_inv_sqrt)\n", - "print(\"\\nNormalised adjacency D\u0302^(-1/2) \u00c2 D\u0302^(-1/2):\\n\",\n", - " norm_adj.round(decimals=4))\n", - "\n", - "print(\"\\n\u2705 GCNConv forward pass verified.\")\n", - "print(\" Output shape (N, D_out) =\", tuple(x_out.shape))" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "dda95b41", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# \u2500\u2500 Visualise the graph and the normalised adjacency matrix \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "\n", - "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", - "fig.suptitle(\"GCN Layer \u2014 Worked Example (N=3 nodes, D_in=4, D_out=2)\",\n", - " fontsize=12, fontweight=\"bold\")\n", - "\n", - "# \u2500\u2500 Panel 1: Graph structure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "ax = axes[0]\n", - "ax.set_title(\"Graph structure\\n(edges 0\u21941, 1\u21942)\", fontweight=\"bold\")\n", - "ax.set_xlim(-0.5, 2.5); ax.set_ylim(-0.5, 1.5); ax.axis(\"off\")\n", - "\n", - "node_pos = {0: (0, 0), 1: (1, 1), 2: (2, 0)}\n", - "for u, v in [(0,1),(1,2)]:\n", - " x0,y0 = node_pos[u]; x1,y1 = node_pos[v]\n", - " ax.plot([x0,x1],[y0,y1],\"k-\",lw=2,zorder=1)\n", - "for nid, (nx_,ny_) in node_pos.items():\n", - " ax.add_patch(plt.Circle((nx_,ny_), 0.18, color=\"#4a90d9\", zorder=2))\n", - " ax.text(nx_, ny_, str(nid), color=\"white\", ha=\"center\", va=\"center\",\n", - " fontsize=13, fontweight=\"bold\", zorder=3)\n", - "ax.text(0,-0.35,\"d\u0302=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", - "ax.text(1, 1.25,\"d\u0302=3\",ha=\"center\",fontsize=9,color=\"#555\")\n", - "ax.text(2,-0.35,\"d\u0302=2\",ha=\"center\",fontsize=9,color=\"#555\")\n", - "\n", - "# \u2500\u2500 Panel 2: Normalised adjacency (heatmap) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "axes[1].set_title(\"Normalised adjacency\\nD\u0302\u207b\u00b9/\u00b2 \u00c2 D\u0302\u207b\u00b9/\u00b2\", fontweight=\"bold\")\n", - "im = axes[1].imshow(norm_adj.numpy(), cmap=\"Blues\", vmin=0, vmax=0.6)\n", - "for i in range(N):\n", - " for j in range(N):\n", - " val = norm_adj[i,j].item()\n", - " axes[1].text(j, i, f\"{val:.3f}\", ha=\"center\", va=\"center\",\n", - " color=\"white\" if val > 0.3 else \"black\", fontsize=10)\n", - "axes[1].set_xticks(range(N)); axes[1].set_yticks(range(N))\n", - "axes[1].set_xticklabels([f\"node {i}\" for i in range(N)])\n", - "axes[1].set_yticklabels([f\"node {i}\" for i in range(N)])\n", - "plt.colorbar(im, ax=axes[1])\n", - "\n", - "# \u2500\u2500 Panel 3: Input X and output X' feature vectors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "axes[2].set_title(\"Feature transformation\\nX (4-dim) \u2192 X' (2-dim)\", fontweight=\"bold\")\n", - "x_np = x_test.detach().numpy()\n", - "xp_np = x_out.detach().numpy()\n", - "\n", - "for i in range(N):\n", - " axes[2].barh([i+0.2]*D_in, x_np[i], height=0.18, left=np.arange(D_in),\n", - " alpha=0.7, color=\"#4a90d9\")\n", - " axes[2].barh([i-0.2]*D_out, xp_np[i], height=0.18, left=np.arange(D_out),\n", - " alpha=0.8, color=\"#e07b54\")\n", - "\n", - "axes[2].set_yticks(range(N))\n", - "axes[2].set_yticklabels([f\"node {i}\" for i in range(N)])\n", - "axes[2].set_xlabel(\"Feature value\")\n", - "blue_p = mpatches.Patch(color=\"#4a90d9\", alpha=0.7, label=\"Input X (D_in=4)\")\n", - "orange_p= mpatches.Patch(color=\"#e07b54\", alpha=0.8, label=\"Output X' (D_out=2)\")\n", - "axes[2].legend(handles=[blue_p, orange_p], fontsize=8, loc=\"lower right\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "213190f2", - "metadata": {}, - "source": [ - "---\n", - "## Section A \u2014 Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", - "\n", - "### Data layout on disk (what we actually have)\n", - "\n", - "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", - "which packages PTB-XL records in a flat WFDB layout \u2014 **no `ptbxl_database.csv`**.\n", - "\n", - "```\n", - "training/ptb-xl/\n", - "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", - "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", - "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 raw signal matrix (12 \u00d7 5000 float, 500 Hz)\n", - "\u2502 \u251c\u2500\u2500 HR00002.hea\n", - "\u2502 \u251c\u2500\u2500 HR00002.mat\n", - "\u2502 \u2514\u2500\u2500 ...\n", - "\u251c\u2500\u2500 g2/\n", - "\u2502 \u2514\u2500\u2500 ...\n", - "\u2514\u2500\u2500 g22/ \u2190 group 22\n", - "```\n", - "\n", - "### What a `.hea` file looks like\n", - "\n", - "```\n", - "HR00001 12 500 5000\n", - "HR00001.mat 16x1+24 1000.0(0)/mv 16 0 -115 13047 0 I\n", - "... (12 lead rows)\n", - "# Age: 56\n", - "# Sex: Female\n", - "# Dx: 251146004,426783006 \u2190 SNOMED-CT codes (comma-separated)\n", - "# Rx: Unknown\n", - "# Hx: Unknown\n", - "# Sx: Unknown\n", - "```\n", - "\n", - "### Goal\n", - "\n", - "Scan all `g*/` directories, parse each `.hea` file, and write a single \n", - "**`ptbxl-pyhealth.csv`** that serves as the metadata index for PyHealth.\n", - "\n", - "| Column | Source | Example |\n", - "|---|---|---|\n", - "| `patient_id` | record name (one ECG = one row in this dataset) | `HR00001` |\n", - "| `record_id` | record name | `HR00001` |\n", - "| `signal_file` | relative path to `.mat` | `g1/HR00001.mat` |\n", - "| `age` | `# Age:` header comment | `56` |\n", - "| `sex` | `# Sex:` header comment | `Female` |\n", - "| `scp_codes` | `# Dx:` header comment | `251146004,426783006` |\n", - "| `sampling_rate` | first header line (always 500) | `500` |\n", - "| `num_samples` | first header line (always 5000) | `5000` |\n", - "| `num_leads` | first header line (always 12) | `12` |\n", - "| `group` | parent directory name | `g1` |\n" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "55a8f37d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CinC 2020 root : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl\n", - "CSV exists : True (/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv)\n", - "[INFO] Cached CSV found \u2192 /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/training/ptb-xl/ptbxl-pyhealth.csv\n", - "\n", - "Loaded df_meta: (21837, 10) \u2014 21,837 ECGs \u00d7 10 columns\n" - ] - } - ], - "source": [ - "import re\n", - "import pandas as pd\n", - "from pathlib import Path\n", - "from typing import Optional\n", - "\n", - "# \u2500\u2500 Section A paths \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# CinC 2020 Challenge data: g1/ - g22/ folders with .hea/.mat files\n", - "PTBXL_CHALLENGE_ROOT = Path(\n", - " \"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/\"\n", - " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2/\"\n", - " \"training/ptb-xl\"\n", - ")\n", - "# Output CSV (will be cached \u2014 skip rebuild if already exists)\n", - "CSV_OUTPUT_PATH = PTBXL_CHALLENGE_ROOT / \"ptbxl-pyhealth.csv\"\n", - "\n", - "print(f\"CinC 2020 root : {PTBXL_CHALLENGE_ROOT}\")\n", - "print(f\"CSV exists : {CSV_OUTPUT_PATH.exists()} ({CSV_OUTPUT_PATH})\")\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Helper: parse a single WFDB .hea file\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def parse_hea_file(hea_path: Path) -> Optional[dict]:\n", - " \"\"\"\n", - " Parse one WFDB header file (.hea) and return a metadata dict.\n", - "\n", - " Header format (CinC 2020 Challenge):\n", - " Line 0 : \n", - " Lines 1-12: signal info rows (one per lead)\n", - " Comment lines starting with '#':\n", - " # Age: \n", - " # Sex: \n", - " # Dx: ,,...\n", - " \"\"\"\n", - " try:\n", - " lines = hea_path.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines()\n", - " except OSError:\n", - " return None\n", - "\n", - " if not lines:\n", - " return None\n", - "\n", - " parts = lines[0].split()\n", - " if len(parts) < 4:\n", - " return None\n", - " record_id = parts[0]\n", - " num_leads = int(parts[1])\n", - " fs = int(parts[2])\n", - " num_samples = int(parts[3])\n", - "\n", - " age, sex, scp_codes = None, \"Unknown\", \"\"\n", - " for line in lines:\n", - " line = line.strip()\n", - " if line.startswith(\"# Age:\"):\n", - " try: age = int(float(line.split(\":\", 1)[1].strip()))\n", - " except ValueError: age = None\n", - " elif line.startswith(\"# Sex:\"):\n", - " sex = line.split(\":\", 1)[1].strip()\n", - " elif line.startswith(\"# Dx:\"):\n", - " scp_codes = line.split(\":\", 1)[1].strip()\n", - "\n", - " group = hea_path.parent.name\n", - " signal_file = f\"{group}/{record_id}.mat\"\n", - "\n", - " return {\"patient_id\": record_id, \"record_id\": record_id,\n", - " \"signal_file\": signal_file, \"age\": age, \"sex\": sex,\n", - " \"scp_codes\": scp_codes, \"sampling_rate\": fs,\n", - " \"num_samples\": num_samples, \"num_leads\": num_leads, \"group\": group}\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Main builder: scan all g* directories \u2192 ptbxl-pyhealth.csv\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def build_ptbxl_csv(root: Path, output_path: Path, force: bool = False) -> pd.DataFrame:\n", - " if output_path.exists() and not force:\n", - " print(f\"[INFO] Cached CSV found \u2192 {output_path}\")\n", - " return pd.read_csv(output_path)\n", - "\n", - " group_dirs = sorted(\n", - " [d for d in root.iterdir() if d.is_dir() and re.match(r\"g\\d+$\", d.name)],\n", - " key=lambda d: int(d.name[1:])\n", - " )\n", - " if not group_dirs:\n", - " raise FileNotFoundError(f\"No g*/ dirs under {root}\")\n", - "\n", - " print(f\"Found {len(group_dirs)} groups: {[d.name for d in group_dirs[:3]]} ...\")\n", - " records, failed = [], 0\n", - " for gd in group_dirs:\n", - " for hea_path in sorted(gd.glob(\"*.hea\")):\n", - " row = parse_hea_file(hea_path)\n", - " if row is None: failed += 1\n", - " else: records.append(row)\n", - "\n", - " df = pd.DataFrame(records, columns=[\n", - " \"patient_id\",\"record_id\",\"signal_file\",\"age\",\"sex\",\"scp_codes\",\n", - " \"sampling_rate\",\"num_samples\",\"num_leads\",\"group\"\n", - " ])\n", - " output_path.parent.mkdir(parents=True, exist_ok=True)\n", - " df.to_csv(output_path, index=False)\n", - " print(f\"[DONE] {len(df):,} records | {failed} failed \u2192 {output_path}\")\n", - " return df\n", - "\n", - "\n", - "# \u2500\u2500 Run (uses cached CSV if present) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "df_meta = build_ptbxl_csv(PTBXL_CHALLENGE_ROOT, CSV_OUTPUT_PATH, force=False)\n", - "print(f\"\\nLoaded df_meta: {df_meta.shape} \u2014 {df_meta.shape[0]:,} ECGs \u00d7 {df_meta.shape[1]} columns\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "ab0625a5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - " PTB-XL / CinC 2020 \u2014 ptbxl-pyhealth.csv statistics\n", - "============================================================\n", - " Total recordings : 21,837\n", - " Groups (folders) : 22\n", - " Sampling rate (Hz): [500]\n", - " Leads per record : [12]\n", - " Samples/record : [5000]\n", - "\n", - " Age distribution:\n", - " min=2 median=62 max=300 missing=89\n", - "\n", - " Sex breakdown:\n", - "Male 11379\n", - "Female 10458\n", - "\n", - " Records per group:\n", - "group count\n", - " g1 999\n", - " g10 1000\n", - " g11 1000\n", - " g12 1000\n", - " g13 1000\n", - " g14 1000\n", - " g15 1000\n", - " g16 1000\n", - " g17 1000\n", - " g18 1000\n", - " g19 1000\n", - " g2 1000\n", - " g20 1000\n", - " g21 1000\n", - " g22 838\n", - " g3 1000\n", - " g4 1000\n", - " g5 1000\n", - " g6 1000\n", - " g7 1000\n", - " g8 1000\n", - " g9 1000\n", - "\n", - " Unique SNOMED-CT codes : 50\n", - " Top-10 Dx codes:\n", - " 426783006 18092 recordings\n", - " 164865005 5261 recordings\n", - " 39732003 5146 recordings\n", - " 164951009 3389 recordings\n", - " 164873001 2359 recordings\n", - " 164934002 2345 recordings\n", - " 164861001 2175 recordings\n", - " 445118002 1626 recordings\n", - " 164889003 1514 recordings\n", - " 164884008 1154 recordings\n", - "\n", - "Preview (first 5 rows):\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
patient_idrecord_idsignal_fileagesexscp_codessampling_ratenum_samplesnum_leadsgroup
0HR00001HR00001g1/HR00001.mat56.0Female251146004,426783006500500012g1
1HR00002HR00002g1/HR00002.mat19.0Male426177001,426783006500500012g1
2HR00003HR00003g1/HR00003.mat37.0Female426783006500500012g1
3HR00004HR00004g1/HR00004.mat24.0Male426783006500500012g1
4HR00005HR00005g1/HR00005.mat19.0Female426783006500500012g1
\n", - "
" - ], - "text/plain": [ - " patient_id record_id signal_file age sex scp_codes \\\n", - "0 HR00001 HR00001 g1/HR00001.mat 56.0 Female 251146004,426783006 \n", - "1 HR00002 HR00002 g1/HR00002.mat 19.0 Male 426177001,426783006 \n", - "2 HR00003 HR00003 g1/HR00003.mat 37.0 Female 426783006 \n", - "3 HR00004 HR00004 g1/HR00004.mat 24.0 Male 426783006 \n", - "4 HR00005 HR00005 g1/HR00005.mat 19.0 Female 426783006 \n", - "\n", - " sampling_rate num_samples num_leads group \n", - "0 500 5000 12 g1 \n", - "1 500 5000 12 g1 \n", - "2 500 5000 12 g1 \n", - "3 500 5000 12 g1 \n", - "4 500 5000 12 g1 " - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# \u2500\u2500 Dataset statistics (mirrors HW5 dataset.stat() style) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "print(\"=\" * 60)\n", - "print(\" PTB-XL / CinC 2020 \u2014 ptbxl-pyhealth.csv statistics\")\n", - "print(\"=\" * 60)\n", - "print(f\" Total recordings : {len(df_meta):,}\")\n", - "print(f\" Groups (folders) : {df_meta['group'].nunique()}\")\n", - "print(f\" Sampling rate (Hz): {df_meta['sampling_rate'].unique().tolist()}\")\n", - "print(f\" Leads per record : {df_meta['num_leads'].unique().tolist()}\")\n", - "print(f\" Samples/record : {df_meta['num_samples'].unique().tolist()}\")\n", - "print()\n", - "print(\" Age distribution:\")\n", - "print(f\" min={df_meta['age'].min():.0f} median={df_meta['age'].median():.0f}\"\n", - " f\" max={df_meta['age'].max():.0f} missing={df_meta['age'].isna().sum()}\")\n", - "print()\n", - "print(\" Sex breakdown:\")\n", - "print(df_meta['sex'].value_counts().to_string(header=False))\n", - "print()\n", - "print(\" Records per group:\")\n", - "print(df_meta.groupby('group').size()\n", - " .reset_index(name='count')\n", - " .to_string(index=False))\n", - "print()\n", - "\n", - "# \u2500\u2500 Dx / SNOMED code distribution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "from collections import Counter\n", - "code_counter = Counter()\n", - "for codes in df_meta['scp_codes'].dropna():\n", - " for c in str(codes).split(','):\n", - " c = c.strip()\n", - " if c:\n", - " code_counter[c] += 1\n", - "\n", - "print(f\" Unique SNOMED-CT codes : {len(code_counter)}\")\n", - "print(\" Top-10 Dx codes:\")\n", - "for code, cnt in code_counter.most_common(10):\n", - " print(f\" {code:15s} {cnt:5d} recordings\")\n", - "\n", - "print()\n", - "print(\"Preview (first 5 rows):\")\n", - "df_meta.head()\n" - ] - }, - { - "cell_type": "markdown", - "id": "efc37ea8", - "metadata": {}, - "source": [ - "\n", - "Following the **HW5 PyHealth pattern** (Dataset \u2192 set_task \u2192 DataLoader \u2192 Model \u2192 Train \u2192 Evaluate), \n", - "here we show how `ptbxl-pyhealth.csv` feeds directly into a PyHealth-style pipeline.\n", - "\n", - "### Architecture overview\n", - "\n", - "```\n", - "ptbxl-pyhealth.csv (built in Section A above)\n", - " \u2502\n", - " \u25bc\n", - "PTBXLRecordDataset(root, csv) # Loads metadata, groups records by ID\n", - " \u2502\n", - " \u25bc .set_task(ptbxl_multilabel_fn)\n", - "PTBXLSampleDataset \u2014 list of samples # Each sample = {patient_id, record_id,\n", - " # signal: np.ndarray (12,T), labels: List[str],\n", - " # label_vec: np.ndarray (5,), age, sex}\n", - " \u2502\n", - " \u251c\u2500\u2500 split_by_sample((0.7, 0.1, 0.2), seed=42)\n", - " \u2502 \u251c\u2500\u2500 train_loader (15,166 samples, batch_size=32, shuffle=True)\n", - " \u2502 \u251c\u2500\u2500 val_loader ( 2,166 samples)\n", - " \u2502 \u2514\u2500\u2500 test_loader ( 4,334 samples)\n", - " \u25bc\n", - "Your model (SparcNet / BiLSTMECG)\n", - " \u2502 trainer.train(train_loader, val_loader, epochs=5)\n", - " \u25bc\n", - "trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro\n", - "```\n", - "\n", - "### SNOMED-CT \u2192 Superdiagnostic mapping (5 classes)\n", - "\n", - "A ~30-code subset defined locally in this section (distinct from the 46-code map used in Step 6):\n", - "\n", - "| Class | Meaning | Example SNOMED codes |\n", - "|---|---|---|\n", - "| `NORM` | Normal sinus rhythm | 426783006 |\n", - "| `MI` | Myocardial infarction | 164865005, 89792004, 413444003, \u2026 |\n", - "| `STTC` | ST/T-change | 164934002, 164931005, 428750005, \u2026 |\n", - "| `CD` | Conduction disturbance | 270492004, 164889003, 445118002, \u2026 |\n", - "| `HYP` | Hypertrophy / axis deviation | 164873001, 164862005, 111975006, \u2026 |" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "3c137a37", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All dataset / task helpers defined.\n" - ] - } - ], - "source": [ - "import scipy.io\n", - "import numpy as np\n", - "import torch\n", - "from torch.utils.data import Dataset, DataLoader\n", - "from pathlib import Path\n", - "from typing import Optional\n", - "\n", - "# \u2500\u2500 SNOMED-CT \u2192 5-class superdiagnostic mapping \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Source: PTB-XL paper (Wagner et al. 2020) Supplementary Table S3\n", - "SNOMED_TO_SUPERDIAG = {\n", - " # NORM\n", - " \"426783006\": \"NORM\",\n", - " # MI\n", - " \"57054005\": \"MI\", \"164909002\": \"MI\", \"413444003\": \"MI\",\n", - " \"164884008\": \"MI\", \"59118001\": \"MI\", \"164865005\": \"MI\",\n", - " \"89792004\": \"MI\",\n", - " # STTC \n", - " \"428750005\": \"STTC\", \"164931005\": \"STTC\", \"164934002\": \"STTC\",\n", - " \"164930006\": \"STTC\", \"164861001\": \"STTC\", \"55827005\": \"STTC\",\n", - " \"164883002\": \"STTC\", \"428417006\": \"STTC\", \"164867002\": \"STTC\",\n", - " \"266257000\": \"STTC\",\n", - " # CD\n", - " \"270492004\": \"CD\", \"164890007\": \"CD\", \"59118001\": \"CD\",\n", - " \"164889003\": \"CD\", \"251146004\": \"CD\", \"698252002\": \"CD\",\n", - " \"164909002\": \"CD\", \"10370003\": \"CD\", \"445118002\": \"CD\",\n", - " \"426627000\": \"CD\", \"713426002\": \"CD\",\n", - " # HYP\n", - " \"164873001\": \"HYP\", \"164862005\": \"HYP\", \"164867002\": \"HYP\",\n", - " \"164873001\": \"HYP\", \"111975006\": \"HYP\",\n", - "}\n", - "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# PyHealth-compatible Dataset (mirrors HW5's MIMIC3Dataset interface)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLRecordDataset:\n", - " \"\"\"\n", - " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", - "\n", - " Usage (HW5 pattern):\n", - " ds = PTBXLRecordDataset(root=PTBXL_CHALLENGE_ROOT, csv=CSV_OUTPUT_PATH)\n", - " samples = ds.set_task(ptbxl_multilabel_fn)\n", - "\n", - " Parameters\n", - " ----------\n", - " root : Path to training/ptb-xl/ (signal .mat files resolved relative here)\n", - " csv : Path to ptbxl-pyhealth.csv\n", - " sampling_rate: 500 (native) or 100 (decimated 5\u00d7)\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " root: Path,\n", - " csv: Path,\n", - " sampling_rate: int = 100, # 100 Hz = decimated; 500 Hz = native\n", - " ):\n", - " self.root = Path(root)\n", - " self.sampling_rate = sampling_rate\n", - " self._df = pd.read_csv(csv)\n", - " # Build patients dict \u2014 one \"visit\" per recording (HW5 analogy)\n", - " self.patients = {\n", - " row[\"patient_id\"]: row.to_dict()\n", - " for _, row in self._df.iterrows()\n", - " }\n", - " print(f\"[PTBXLRecordDataset] Loaded {len(self.patients):,} records \"\n", - " f\"from {csv.name} @ {sampling_rate} Hz target\")\n", - "\n", - " # \u2500\u2500 stat(): mirrors HW5 dataset.stat() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " def stat(self):\n", - " df = self._df\n", - " print(\"=\" * 55)\n", - " print(\" PTBXLRecordDataset statistics\")\n", - " print(\"=\" * 55)\n", - " print(f\" Records : {len(df):,}\")\n", - " print(f\" Groups : {df['group'].nunique()}\")\n", - " print(f\" Unique Dx codes: \"\n", - " + str(len({c.strip()\n", - " for codes in df['scp_codes'].dropna()\n", - " for c in str(codes).split(',')})))\n", - " print(\"=\" * 55)\n", - "\n", - " # \u2500\u2500 set_task(): mirrors HW5 dataset.set_task() \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " def set_task(self, task_fn) -> \"PTBXLSampleDataset\":\n", - " \"\"\"Apply a task function to every record and return a SampleDataset.\"\"\"\n", - " samples = []\n", - " for pid, record in self.patients.items():\n", - " result = task_fn(record, root=self.root,\n", - " sampling_rate=self.sampling_rate)\n", - " if result is not None:\n", - " samples.append(result)\n", - " print(f\"[set_task] {len(samples):,} samples generated \"\n", - " f\"(from {len(self.patients):,} records, \"\n", - " f\"{len(self.patients)-len(samples)} skipped/no-label)\")\n", - " return PTBXLSampleDataset(samples)\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Task function: multilabel superdiagnostic classification\n", - "# (mirrors HW5's mortality_prediction_mimic3_fn)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def ptbxl_multilabel_fn(record: dict, root: Path, sampling_rate: int = 100) -> Optional[dict]:\n", - " \"\"\"\n", - " Convert one PTB-XL record dict (a row from ptbxl-pyhealth.csv) into\n", - " a PyHealth-style sample dict.\n", - "\n", - " Returns\n", - " -------\n", - " dict with keys:\n", - " patient_id : str\n", - " record_id : str\n", - " signal : np.ndarray shape (num_leads, T)\n", - " labels : list[str] superdiagnostic classes present\n", - " label_vec : np.ndarray shape (5,) multi-hot for NORM/MI/STTC/CD/HYP\n", - " Or None if the signal file is missing or no valid label can be derived.\n", - " \"\"\"\n", - " mat_path = root / record[\"signal_file\"]\n", - " if not mat_path.exists():\n", - " return None\n", - "\n", - " # \u2500\u2500 Load signal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " try:\n", - " mat = scipy.io.loadmat(str(mat_path))\n", - " # CinC 2020 .mat stores signal under key 'val' (shape 12\u00d75000)\n", - " signal = mat[\"val\"].astype(np.float32) # (12, 5000)\n", - " except Exception:\n", - " return None\n", - "\n", - " # \u2500\u2500 Decimate to target sampling rate \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " if sampling_rate == 100:\n", - " signal = signal[:, ::5] # 500 Hz \u2192 100 Hz ( stride 5 )\n", - "\n", - " # \u2500\u2500 Map Dx codes \u2192 superdiagnostic classes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " scp_raw = str(record.get(\"scp_codes\", \"\"))\n", - " codes = [c.strip() for c in scp_raw.split(\",\") if c.strip()]\n", - " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", - "\n", - " if not labels:\n", - " return None # skip records with no mappable superdiagnostic code\n", - "\n", - " # \u2500\u2500 Multi-hot label vector (matches HW5 label pattern) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", - " for lbl in labels:\n", - " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", - "\n", - " return {\n", - " \"patient_id\": record[\"patient_id\"],\n", - " \"record_id\": record[\"record_id\"],\n", - " \"signal\": signal, # np.ndarray (12, T)\n", - " \"labels\": labels, # e.g. [\"NORM\"]\n", - " \"label_vec\": label_vec, # np.ndarray (5,)\n", - " \"age\": record.get(\"age\"),\n", - " \"sex\": record.get(\"sex\"),\n", - " }\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# SampleDataset + DataLoader helpers\n", - "# (mirrors HW5's SampleDataset / get_dataloader)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLSampleDataset(Dataset):\n", - " \"\"\"Thin wrapper around a list of sample dicts \u2014 compatible with DataLoader.\"\"\"\n", - "\n", - " def __init__(self, samples: list):\n", - " self.samples = samples\n", - "\n", - " def __len__(self):\n", - " return len(self.samples)\n", - "\n", - " def __getitem__(self, idx: int):\n", - " s = self.samples[idx]\n", - " return {\n", - " \"signal\": torch.from_numpy(s[\"signal\"]), # (12, T)\n", - " \"label_vec\": torch.from_numpy(s[\"label_vec\"]), # (5,)\n", - " \"labels\": s[\"labels\"],\n", - " }\n", - "\n", - " def stat(self):\n", - " from collections import Counter\n", - " all_labels = [lbl for s in self.samples for lbl in s[\"labels\"]]\n", - " cnt = Counter(all_labels)\n", - " print(f\"Total samples : {len(self.samples):,}\")\n", - " print(\"Label distribution:\")\n", - " for cls in SUPERDIAG_CLASSES:\n", - " print(f\" {cls:5s}: {cnt.get(cls,0):5d} ({cnt.get(cls,0)/len(self.samples)*100:.1f}%)\")\n", - "\n", - "\n", - "def split_by_sample(dataset: PTBXLSampleDataset, ratios=(0.7, 0.1, 0.2), seed=42):\n", - " \"\"\"Random split by sample index (mirrors HW5's split_by_sample).\"\"\"\n", - " n = len(dataset)\n", - " idx = np.random.default_rng(seed).permutation(n)\n", - " n_train = int(ratios[0] * n)\n", - " n_val = int(ratios[1] * n)\n", - " return (\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[:n_train]]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train:n_train+n_val]]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in idx[n_train+n_val:]]),\n", - " )\n", - "\n", - "\n", - "def get_dataloader(dataset: PTBXLSampleDataset, batch_size: int = 32,\n", - " shuffle: bool = False) -> DataLoader:\n", - " \"\"\"Wrap PTBXLSampleDataset in a DataLoader (mirrors HW5's get_dataloader).\"\"\"\n", - " def collate_fn(batch):\n", - " return {\n", - " \"signal\": torch.stack([b[\"signal\"] for b in batch]), # (B,12,T)\n", - " \"label_vec\": torch.stack([b[\"label_vec\"] for b in batch]), # (B,5)\n", - " \"labels\": [b[\"labels\"] for b in batch],\n", - " }\n", - " return DataLoader(dataset, batch_size=batch_size,\n", - " shuffle=shuffle, collate_fn=collate_fn)\n", - "\n", - "\n", - "print(\"All dataset / task helpers defined.\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "0a41c8f8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[PTBXLRecordDataset] Loaded 21,837 records from ptbxl-pyhealth.csv @ 100 Hz target\n", - "=======================================================\n", - " PTBXLRecordDataset statistics\n", - "=======================================================\n", - " Records : 21,837\n", - " Groups : 22\n", - " Unique Dx codes: 50\n", - "=======================================================\n", - "[set_task] 21,666 samples generated (from 21,837 records, 171 skipped/no-label)\n", - "Total samples : 21,666\n", - "Label distribution:\n", - " NORM : 18092 (83.5%)\n", - " MI : 6046 (27.9%)\n", - " STTC : 4550 (21.0%)\n", - " CD : 5999 (27.7%)\n", - " HYP : 2466 (11.4%)\n", - "\n", - "Splits \u2192 train: 15,166 | val: 2,166 | test: 4,334\n", - "Batches/epoch : 474\n", - "\n", - "One training batch:\n", - " signal shape : torch.Size([32, 12, 1000])\n", - " label_vec shape: torch.Size([32, 5])\n", - " classes present: ['CD', 'HYP', 'MI', 'NORM', 'STTC']\n", - "\n", - "Ready for Stage 4: plug into SparcNet / BiLSTM / Transformer!\n", - "(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for full training loop)\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Full pipeline run (HW5-style 5 stages) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "\n", - "# Stage 1: Load dataset\n", - "ptbxl_ds = PTBXLRecordDataset(\n", - " root=PTBXL_CHALLENGE_ROOT,\n", - " csv=CSV_OUTPUT_PATH,\n", - " sampling_rate=100, # 100 Hz (decimated from 500 Hz)\n", - ")\n", - "ptbxl_ds.stat()\n", - "\n", - "# Stage 2: Define task\n", - "ptbxl_samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", - "ptbxl_samples.stat()\n", - "print()\n", - "\n", - "# Stage 3: Split + DataLoaders\n", - "train_ds, val_ds, test_ds = split_by_sample(ptbxl_samples, ratios=(0.7, 0.1, 0.2))\n", - "train_loader = get_dataloader(train_ds, batch_size=32, shuffle=True)\n", - "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", - "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", - "\n", - "print(f\"Splits \u2192 train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}\")\n", - "print(f\"Batches/epoch : {len(train_loader)}\")\n", - "\n", - "# \u2500\u2500 Peek at one batch (like HW4's data verification) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "batch = next(iter(train_loader))\n", - "print()\n", - "print(\"One training batch:\")\n", - "print(f\" signal shape : {batch['signal'].shape}\") # (32, 12, 1000)\n", - "print(f\" label_vec shape: {batch['label_vec'].shape}\") # (32, 5)\n", - "print(f\" classes present: {sorted(set(l for lbls in batch['labels'] for l in lbls))}\")\n", - "print()\n", - "print(\"Ready for Stage 4: plug into SparcNet / BiLSTM / Transformer!\")\n", - "print(\"(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for full training loop)\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "0c0b861a", - "metadata": {}, - "source": [ - "---\n", - "## Section A \u2014 Build `ptbxl-pyhealth.csv` from CinC 2020 Challenge Files\n", - "\n", - "### Data layout on disk (what we actually have)\n", - "\n", - "The data in this project comes from the **PhysioNet/CinC 2020 Challenge** (v1.0.2), \n", - "which packages PTB-XL records in a flat WFDB layout \u2014 **no `ptbxl_database.csv`**.\n", - "\n", - "```\n", - "training/ptb-xl/\n", - "\u251c\u2500\u2500 g1/ \u2190 group 1 (\u22481000 recordings each)\n", - "\u2502 \u251c\u2500\u2500 HR00001.hea \u2190 WFDB header: leads, fs, calibration + metadata comments\n", - "\u2502 \u251c\u2500\u2500 HR00001.mat \u2190 raw signal matrix (12 \u00d7 5000 float, 500 Hz)\n", - "\u2502 \u251c\u2500\u2500 HR00002.hea\n", - "\u2502 \u2514\u2500\u2500 ...\n", - "\u251c\u2500\u2500 g2/ ... g22/\n", - "```\n", - "\n", - "### What a `.hea` header file looks like\n", - "\n", - "```\n", - "HR00001 12 500 5000\n", - "HR00001.mat 16x1+24 1000.0(0)/mv 16 0 -115 13047 0 I\n", - "... (12 signal rows)\n", - "# Age: 56\n", - "# Sex: Female\n", - "# Dx: 251146004,426783006 \u2190 SNOMED-CT codes, comma-separated\n", - "# Rx: Unknown\n", - "```\n", - "\n", - "### CSV schema produced\n", - "\n", - "| Column | Source | Example |\n", - "|---|---|---|\n", - "| `patient_id` | record name | `HR00001` |\n", - "| `record_id` | record name | `HR00001` |\n", - "| `signal_file` | relative path to `.mat` | `g1/HR00001.mat` |\n", - "| `age` | `# Age:` comment | `56` |\n", - "| `sex` | `# Sex:` comment | `Female` |\n", - "| `scp_codes` | `# Dx:` comment | `251146004,426783006` |\n", - "| `sampling_rate` | line-0 field | `500` |\n", - "| `num_samples` | line-0 field | `5000` |\n", - "| `num_leads` | line-0 field | `12` |\n", - "| `group` | parent dir name | `g1` |\n" - ] - }, - { - "cell_type": "markdown", - "id": "1a07dd75", - "metadata": {}, - "source": [ - "## \ud83d\udce5 Download PTB-XL 1.0.3 (Full Dataset)\n", - "\n", - "The YAML config and Section B pipeline use the **official PTB-XL 1.0.3** dataset from PhysioNet, which includes:\n", - "- `ptbxl_database.csv` \u2014 21,799 ECG records \u00d7 28 metadata columns\n", - "- `scp_statements.csv` \u2014 71 SCP-ECG codes with diagnostic class mappings\n", - "- `records100/` \u2014 100 Hz WFDB signals (`.hea` + `.dat`)\n", - "- `records500/` \u2014 500 Hz WFDB signals (`.hea` + `.dat`)\n", - "\n", - "**Why not the Kaggle `physionet/ptbxl-electrocardiography-database`?** \n", - "That Kaggle dataset contains only WFDB `.hea`/`.mat` files (CinC 2020 challenge format) \u2014 **no** `ptbxl_database.csv`. \n", - "For the full metadata, use: `garethwmch/ptb-xl-1-0-3` (87k files, CC0 license).\n", - "\n", - "**Download options (run the cell below):**\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "c0a20bba", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PTB-XL asset audit\n", - "============================================================\n", - " ptbxl_database.csv : \u2705 6440 KB\n", - " scp_statements.csv : \u2705 9 KB\n", - " WFDB/ signals : \u2705 21,837 .mat files (500 Hz)\n", - " records100/ (100Hz): \u274c not present \u2014 using WFDB/ flat folder instead\n", - " records500/ (500Hz): \u274c not present \u2014 using WFDB/ flat folder instead\n", - "\n", - "\u2705 All required data present \u2014 proceed to Section B!\n", - "\n", - " Data layout:\n", - " \u2022 Metadata CSV : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/ptbxl_database.csv\n", - " \u2022 SCP codes : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/scp_statements.csv\n", - " \u2022 Signal files : /Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project/WFDB/HR{ecg_id:05d}.mat (500 Hz, 12-lead)\n", - "\n", - " NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\n", - " The WFDB/ .mat files are the same PTB-XL signals \u2014 just flat layout.\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "# \u2500\u2500 Locate PTB-XL assets \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", - "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\"\n", - "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\"\n", - "WFDB_ROOT = PROJECT_ROOT / \"WFDB\"\n", - "\n", - "print(\"PTB-XL asset audit\")\n", - "print(\"=\" * 60)\n", - "print(f\" ptbxl_database.csv : {'\u2705 ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '\u274c not found'}\")\n", - "print(f\" scp_statements.csv : {'\u2705 ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '\u274c not found'}\")\n", - "\n", - "if WFDB_ROOT.is_dir():\n", - " n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\"))\n", - " print(f\" WFDB/ signals : \u2705 {n_mat:,} .mat files (500 Hz)\")\n", - "else:\n", - " print(f\" WFDB/ signals : \u274c not found at {WFDB_ROOT}\")\n", - "\n", - "records100 = PROJECT_ROOT / \"records100\"\n", - "records500 = PROJECT_ROOT / \"records500\"\n", - "print(f\" records100/ (100Hz): {'\u2705' if records100.is_dir() else '\u274c not present \u2014 using WFDB/ flat folder instead'}\")\n", - "print(f\" records500/ (500Hz): {'\u2705' if records500.is_dir() else '\u274c not present \u2014 using WFDB/ flat folder instead'}\")\n", - "\n", - "print()\n", - "if PTBXL_DATABASE_CSV.exists() and WFDB_ROOT.is_dir():\n", - " print(\"\u2705 All required data present \u2014 proceed to Section B!\")\n", - " print()\n", - " print(\" Data layout:\")\n", - " print(f\" \u2022 Metadata CSV : {PTBXL_DATABASE_CSV}\")\n", - " print(f\" \u2022 SCP codes : {SCP_STATEMENTS_CSV}\")\n", - " print(f\" \u2022 Signal files : {WFDB_ROOT}/HR{{ecg_id:05d}}.mat (500 Hz, 12-lead)\")\n", - " print()\n", - " print(\" NOTE: records100/ and records500/ (WFDB .dat format) are NOT needed.\")\n", - " print(\" The WFDB/ .mat files are the same PTB-XL signals \u2014 just flat layout.\")\n", - "else:\n", - " print(\"\u26a0\ufe0f Missing required files. Download options:\")\n", - " print()\n", - " print(\"\u2500\u2500 Option A: CSVs only from PhysioNet (no account, ~5 MB) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\")\n", - " print(f\" cd {PROJECT_ROOT}\")\n", - " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/ptbxl_database.csv\")\n", - " print(\" curl -O https://physionet.org/files/ptb-xl/1.0.3/scp_statements.csv\")\n", - " print()\n", - " print(\"\u2500\u2500 Option B: Full dataset incl. records100/500 (~3.2 GB, Kaggle) \u2500\u2500\u2500\u2500\u2500\")\n", - " print(\" kaggle datasets download -d garethwmch/ptb-xl-1-0-3 --unzip \\\\\")\n", - " print(f\" -p \\\"{PROJECT_ROOT}\\\"\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "b406bc94", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ptbxl_database.csv : \u2705 6440 KB\n", - "scp_statements.csv : \u2705 9 KB\n", - "WFDB/ signals : \u2705 21837 .mat files\n", - "Signal FS : 500 Hz \u2192 T=5000 samples per recording\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "# \u2500\u2500 PTB-XL paths (CSVs at project root; signals in WFDB/ flat .mat folder) \u2500\u2500\u2500\u2500\n", - "PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", - "\n", - "PTBXL_DATABASE_CSV = PROJECT_ROOT / \"ptbxl_database.csv\" # 21,799 rows \u00d7 28 cols\n", - "SCP_STATEMENTS_CSV = PROJECT_ROOT / \"scp_statements.csv\" # 71 SCP-ECG codes\n", - "WFDB_ROOT = PROJECT_ROOT / \"WFDB\" # HR00001.mat - HR21837.mat\n", - "RECORDS_CSV = PROJECT_ROOT / \"ptbxl-records-pyhealth.csv\" # auto-generated below\n", - "\n", - "# Signal files are 500 Hz, channel-first (12, 5000)\n", - "# ecg_id \u2192 WFDB/HR{ecg_id:05d}.mat\n", - "SIGNAL_FS = 500 # Hz (5000 samples per 10s recording)\n", - "\n", - "print(f\"ptbxl_database.csv : {'\u2705 ' + str(PTBXL_DATABASE_CSV.stat().st_size // 1024) + ' KB' if PTBXL_DATABASE_CSV.exists() else '\u274c not found \u2014 run download cell'}\")\n", - "print(f\"scp_statements.csv : {'\u2705 ' + str(SCP_STATEMENTS_CSV.stat().st_size // 1024) + ' KB' if SCP_STATEMENTS_CSV.exists() else '\u274c not found'}\")\n", - "n_mat = sum(1 for _ in WFDB_ROOT.glob(\"*.mat\")) if WFDB_ROOT.is_dir() else 0\n", - "print(f\"WFDB/ signals : {'\u2705 ' + str(n_mat) + ' .mat files' if n_mat else '\u274c not found'}\")\n", - "print(f\"Signal FS : {SIGNAL_FS} Hz \u2192 T=5000 samples per recording\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "22272151", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ptbxl-records-pyhealth.csv already exists (5054 KB)\n", - "\u2705 Section B helpers defined (lazy signal loading):\n", - " build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\n", - " PTBXLSampleDataset | split_by_fold | get_dataloader\n", - "\n", - " Memory strategy: LAZY \u2014 signals loaded per-batch from WFDB/*.mat\n", - " Signal format : WFDB/HR{ecg_id:05d}.mat \u2192 (12, 5000) float32 mV @ 500 Hz\n", - " Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\n" - ] - } - ], - "source": [ - "import ast\n", - "import scipy.io as sio\n", - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "from collections import Counter\n", - "from pathlib import Path\n", - "from typing import List, Optional, Tuple\n", - "from torch.utils.data import Dataset, DataLoader\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Step 0: Build ptbxl-records-pyhealth.csv (adds wfdb_file column)\n", - "# Derived from ptbxl_database.csv; run once then cached.\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def build_records_csv(db_csv: Path, wfdb_root: Path, out_csv: Path) -> pd.DataFrame:\n", - " \"\"\"\n", - " Create ptbxl-records-pyhealth.csv from ptbxl_database.csv by adding:\n", - " wfdb_file : \"WFDB/HR{ecg_id:05d}.mat\" (one per ECG, flat layout)\n", - " Only rows whose .mat file exists in wfdb_root are included.\n", - " \"\"\"\n", - " df = pd.read_csv(db_csv, index_col=\"ecg_id\")\n", - " df[\"wfdb_file\"] = [f\"WFDB/HR{eid:05d}.mat\" for eid in df.index]\n", - "\n", - " exists_mask = [(wfdb_root / f\"HR{eid:05d}.mat\").exists() for eid in df.index]\n", - " missing = sum(1 for e in exists_mask if not e)\n", - " df = df[exists_mask]\n", - "\n", - " records_cols = [\n", - " \"patient_id\", \"recording_date\",\n", - " \"ecg_id\", \"wfdb_file\",\n", - " \"scp_codes\", \"report\", \"heart_axis\",\n", - " \"infarction_stadium1\", \"infarction_stadium2\",\n", - " \"validated_by\", \"second_opinion\",\n", - " \"initial_autogenerated_report\", \"validated_by_human\",\n", - " \"baseline_drift\", \"static_noise\", \"burst_noise\",\n", - " \"electrodes_problems\", \"extra_beats\", \"pacemaker\",\n", - " \"strat_fold\",\n", - " ]\n", - " df = df.reset_index()\n", - " out = df[[c for c in records_cols if c in df.columns]]\n", - " out.to_csv(out_csv, index=False)\n", - " print(f\"[build_records_csv] {len(out):,} records written to {out_csv.name}\")\n", - " if missing:\n", - " print(f\" \u26a0\ufe0f {missing} ecg_ids had no matching .mat file (skipped)\")\n", - " return out\n", - "\n", - "if not RECORDS_CSV.exists():\n", - " print(\"Building ptbxl-records-pyhealth.csv ...\")\n", - " _rdf = build_records_csv(PTBXL_DATABASE_CSV, WFDB_ROOT, RECORDS_CSV)\n", - "else:\n", - " print(f\"ptbxl-records-pyhealth.csv already exists ({RECORDS_CSV.stat().st_size // 1024} KB)\")\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Superdiagnostic class definitions\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", - "SUPERDIAG_INDEX = {c: i for i, c in enumerate(SUPERDIAG_CLASSES)}\n", - "\n", - "\n", - "def load_superdiag_map(scp_statements_csv: Path) -> dict:\n", - " df = pd.read_csv(scp_statements_csv, index_col=0)\n", - " df = df[df[\"diagnostic\"] == 1]\n", - " return df[\"diagnostic_class\"].dropna().to_dict()\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# PTBXLRecordDataset \u2014 HW5-style wrapper for PTB-XL 1.0.3\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLRecordDataset:\n", - " \"\"\"\n", - " PyHealth-compatible dataset built from ptbxl_database.csv + WFDB/ signals.\n", - "\n", - " Parameters\n", - " ----------\n", - " db_csv : Path to ptbxl_database.csv\n", - " scp_csv : Path to scp_statements.csv\n", - " wfdb_root : Path to WFDB/ folder (HR*.mat files)\n", - " sampling_rate: 500 Hz (WFDB .mat files)\n", - " \"\"\"\n", - "\n", - " def __init__(self, db_csv: Path, scp_csv: Path, wfdb_root: Path,\n", - " sampling_rate: int = 500):\n", - " self.db_csv = Path(db_csv)\n", - " self.wfdb_root = Path(wfdb_root)\n", - " self.sampling_rate = sampling_rate\n", - " self._samples = None\n", - "\n", - " if not self.db_csv.exists():\n", - " raise FileNotFoundError(f\"ptbxl_database.csv not found: {self.db_csv}\")\n", - "\n", - " self.df = pd.read_csv(self.db_csv, index_col=\"ecg_id\")\n", - " self.df[\"scp_codes\"] = self.df[\"scp_codes\"].apply(ast.literal_eval)\n", - "\n", - " self.superdiag_map = (load_superdiag_map(scp_csv)\n", - " if scp_csv and Path(scp_csv).exists() else {})\n", - "\n", - " # Build patient \u2192 records index\n", - " self.patients: dict = {}\n", - " for ecg_id, row in self.df.iterrows():\n", - " pid = str(int(row[\"patient_id\"]))\n", - " rec = {\"ecg_id\": ecg_id, **row.to_dict()}\n", - " self.patients.setdefault(pid, []).append(rec)\n", - "\n", - " def stat(self):\n", - " n_rec = len(self.df)\n", - " n_pat = len(self.patients)\n", - " age = self.df[\"age\"].dropna()\n", - " sex = self.df[\"sex\"].value_counts()\n", - "\n", - " print(\"=\" * 60)\n", - " print(\" PTBXLRecordDataset.stat() \u2014 PTB-XL 1.0.3\")\n", - " print(\"=\" * 60)\n", - " print(f\" ECG recordings : {n_rec:,}\")\n", - " print(f\" Unique patients : {n_pat:,}\")\n", - " print(f\" Avg recordings / patient : {n_rec/n_pat:.2f}\")\n", - " print(f\" Sampling rate : {self.sampling_rate} Hz (T=5000)\")\n", - " print(f\" SCP diagnostic codes mapped: {len(self.superdiag_map)}\")\n", - " print()\n", - " print(f\" Strat folds : {sorted(self.df['strat_fold'].unique().tolist())}\")\n", - " print(f\" \u2192 Train=1-8 Val=9 Test=10 (no patient leakage by design)\")\n", - " print()\n", - " print(f\" Age min={age.min():.0f} median={age.median():.0f} max={age.max():.0f}\"\n", - " f\" missing={self.df['age'].isna().sum()}\")\n", - " print(f\" Sex Male(0)={sex.get(0,0):,} Female(1)={sex.get(1,0):,}\")\n", - " print()\n", - " cls_counts = Counter()\n", - " for codes in self.df[\"scp_codes\"]:\n", - " for code in codes.keys():\n", - " cls = self.superdiag_map.get(code)\n", - " if cls and cls in SUPERDIAG_INDEX:\n", - " cls_counts[cls] += 1\n", - " print(\" Superdiagnostic class distribution (multi-label):\")\n", - " for cls in SUPERDIAG_CLASSES:\n", - " cnt = cls_counts.get(cls, 0)\n", - " print(f\" {cls:6s}: {cnt:6,} ({100*cnt/n_rec:.1f}%)\")\n", - "\n", - " def set_task(self, task_fn) -> List[dict]:\n", - " \"\"\"\n", - " Apply task_fn to every row. Rows where task_fn returns None are skipped.\n", - " Signal arrays are NOT loaded here \u2014 only metadata is stored.\n", - " Actual signal loading happens lazily in PTBXLSampleDataset.__getitem__.\n", - " \"\"\"\n", - " samples, skipped = [], 0\n", - " for ecg_id, row in self.df.iterrows():\n", - " sample = task_fn(\n", - " record={\"ecg_id\": ecg_id, **row.to_dict()},\n", - " wfdb_root=self.wfdb_root,\n", - " superdiag_map=self.superdiag_map,\n", - " )\n", - " if sample is None:\n", - " skipped += 1\n", - " else:\n", - " samples.append(sample)\n", - "\n", - " self._samples = samples\n", - " print(f\"[set_task] {len(samples):,} samples indexed \"\n", - " f\"({skipped} skipped \u2014 no mappable diagnostic label or missing file)\")\n", - " return samples\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Task function \u2014 builds metadata dict WITHOUT loading signal (lazy)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def ptbxl_multilabel_fn(record: dict, wfdb_root: Path,\n", - " superdiag_map: dict) -> Optional[dict]:\n", - " \"\"\"\n", - " Build a sample dict for one ECG record.\n", - " Signal is NOT loaded here \u2014 path is stored for lazy loading in __getitem__.\n", - "\n", - " Returns None if no diagnostic label can be mapped.\n", - " \"\"\"\n", - " scp_dict = record[\"scp_codes\"]\n", - " superdiags = {superdiag_map[c] for c in scp_dict\n", - " if c in superdiag_map and superdiag_map[c] in SUPERDIAG_INDEX}\n", - " if not superdiags:\n", - " return None\n", - "\n", - " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", - " for cls in superdiags:\n", - " label_vec[SUPERDIAG_INDEX[cls]] = 1.0\n", - "\n", - " # Store path for lazy loading \u2014 do NOT load signal here\n", - " ecg_id = record[\"ecg_id\"]\n", - " mat_path = str(wfdb_root / f\"HR{ecg_id:05d}.mat\")\n", - "\n", - " return {\n", - " \"ecg_id\": ecg_id,\n", - " \"patient_id\": str(int(record[\"patient_id\"])),\n", - " \"mat_path\": mat_path, # loaded on demand in __getitem__\n", - " \"labels\": list(superdiags),\n", - " \"label_vec\": label_vec, # (5,) multi-hot\n", - " \"age\": record.get(\"age\"),\n", - " \"sex\": record.get(\"sex\"), # 0=Male, 1=Female\n", - " \"strat_fold\": int(record.get(\"strat_fold\", 1)),\n", - " }\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# PTBXLSampleDataset \u2014 lazy-loading PyTorch Dataset\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLSampleDataset(Dataset):\n", - " \"\"\"\n", - " Lazy-loading Dataset: signals are read from disk in __getitem__.\n", - " Memory usage: O(metadata only) \u00d7 n_samples \u2014 ~200 MB for 21K records,\n", - " NOT 5+ GB that eager loading would require.\n", - " \"\"\"\n", - " def __init__(self, samples: List[dict]):\n", - " self.samples = samples\n", - "\n", - " def __len__(self):\n", - " return len(self.samples)\n", - "\n", - " def __getitem__(self, idx):\n", - " s = self.samples[idx]\n", - " # Load signal from disk on demand\n", - " data = sio.loadmat(s[\"mat_path\"])\n", - " signal = data[\"val\"].astype(np.float32) / 200.0 # ADC \u2192 mV, (12, 5000)\n", - " return {\n", - " \"signal\": torch.tensor(signal, dtype=torch.float32),\n", - " \"label_vec\": torch.tensor(s[\"label_vec\"], dtype=torch.float32),\n", - " \"ecg_id\": s[\"ecg_id\"],\n", - " }\n", - "\n", - " def stat(self):\n", - " n = len(self.samples)\n", - " label_counts = Counter()\n", - " for s in self.samples:\n", - " for lbl in s[\"labels\"]:\n", - " label_counts[lbl] += 1\n", - " print(f\" Samples : {n:,}\")\n", - " print(\" Label distribution:\")\n", - " for cls in SUPERDIAG_CLASSES:\n", - " cnt = label_counts.get(cls, 0)\n", - " print(f\" {cls:6s}: {cnt:5,} ({100*cnt/n:.1f}%)\")\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# split_by_fold \u2014 PTB-XL strat_fold (zero patient leakage)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def split_by_fold(\n", - " samples: List[dict],\n", - " train_folds: tuple = (1, 2, 3, 4, 5, 6, 7, 8),\n", - " val_folds: tuple = (9,),\n", - " test_folds: tuple = (10,),\n", - ") -> Tuple[List, List, List]:\n", - " \"\"\"\n", - " Split using PTB-XL's strat_fold.\n", - " All records from the same patient guaranteed in the same fold.\n", - " Folds 9 & 10 are human-validated \u2192 highest label quality.\n", - " \"\"\"\n", - " train = [s for s in samples if s[\"strat_fold\"] in train_folds]\n", - " val = [s for s in samples if s[\"strat_fold\"] in val_folds]\n", - " test = [s for s in samples if s[\"strat_fold\"] in test_folds]\n", - " return train, val, test\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# get_dataloader \u2014 batched DataLoader, signals loaded lazily per batch\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def get_dataloader(samples: List[dict], batch_size: int = 32,\n", - " shuffle: bool = False, num_workers: int = 0) -> DataLoader:\n", - " def collate_fn(batch):\n", - " signals = torch.stack([b[\"signal\"] for b in batch]) # (B, 12, 5000)\n", - " label_vecs = torch.stack([b[\"label_vec\"] for b in batch]) # (B, 5)\n", - " ecg_ids = [b[\"ecg_id\"] for b in batch]\n", - " return signals, label_vecs, ecg_ids\n", - "\n", - " return DataLoader(\n", - " PTBXLSampleDataset(samples),\n", - " batch_size=batch_size,\n", - " shuffle=shuffle,\n", - " num_workers=num_workers,\n", - " collate_fn=collate_fn,\n", - " )\n", - "\n", - "print(\"\u2705 Section B helpers defined (lazy signal loading):\")\n", - "print(\" build_records_csv | PTBXLRecordDataset | ptbxl_multilabel_fn\")\n", - "print(\" PTBXLSampleDataset | split_by_fold | get_dataloader\")\n", - "print()\n", - "print(\" Memory strategy: LAZY \u2014 signals loaded per-batch from WFDB/*.mat\")\n", - "print(\" Signal format : WFDB/HR{ecg_id:05d}.mat \u2192 (12, 5000) float32 mV @ 500 Hz\")\n", - "print(\" Label format : 5-class multi-hot NORM | MI | STTC | CD | HYP\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "ae38c7a6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading PTBXLRecordDataset ...\n", - "============================================================\n", - " PTBXLRecordDataset.stat() \u2014 PTB-XL 1.0.3\n", - "============================================================\n", - " ECG recordings : 21,799\n", - " Unique patients : 18,869\n", - " Avg recordings / patient : 1.16\n", - " Sampling rate : 500 Hz (T=5000)\n", - " SCP diagnostic codes mapped: 44\n", - "\n", - " Strat folds : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - " \u2192 Train=1-8 Val=9 Test=10 (no patient leakage by design)\n", - "\n", - " Age min=2 median=62 max=300 missing=0\n", - " Sex Male(0)=11,354 Female(1)=10,445\n", - "\n", - " Superdiagnostic class distribution (multi-label):\n", - " NORM : 9,514 (43.6%)\n", - " MI : 6,863 (31.5%)\n", - " STTC : 5,771 (26.5%)\n", - " CD : 5,761 (26.4%)\n", - " HYP : 2,812 (12.9%)\n", - "\n", - "[set_task] 21,388 samples indexed (411 skipped \u2014 no mappable diagnostic label or missing file)\n", - "\n", - "Stratified split (strat_fold 1-8 / 9 / 10):\n", - " Train : 17,084 samples (folds 1-8)\n", - " Val : 2,146 samples (fold 9 \u2014 human validated)\n", - " Test : 2,158 samples (fold 10 \u2014 human validated)\n", - "\n", - " Patient leakage train\u2229val=0 train\u2229test=0 \u2705 no leakage\n", - "\n", - "Batch verification:\n", - " signals shape : (32, 12, 5000) \u2192 (batch, leads=12, time=5000 @ 500 Hz)\n", - " labels shape : (32, 5) \u2192 (batch, 5-class multi-hot)\n", - "\n", - "\u2705 Section B pipeline verified with real PTB-XL data!\n", - " YAML config : ptbxl_v103_pyhealth.yaml\n", - " Records CSV : ptbxl-records-pyhealth.csv\n", - " Signal FS : 500 Hz \u2192 T=5000 samples/recording\n", - " Classes : ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Guard: skip if required files not present \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "if not PTBXL_DATABASE_CSV.exists():\n", - " print(\"\u26a0\ufe0f ptbxl_database.csv not found \u2014 run download cell first.\")\n", - "elif not WFDB_ROOT.is_dir():\n", - " print(f\"\u26a0\ufe0f WFDB/ folder not found at {WFDB_ROOT}\")\n", - "else:\n", - " # \u2500\u2500 Stage 1: Build dataset from ptbxl_database.csv \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " print(\"Loading PTBXLRecordDataset ...\")\n", - " ptbxl_ds = PTBXLRecordDataset(\n", - " db_csv = PTBXL_DATABASE_CSV,\n", - " scp_csv = SCP_STATEMENTS_CSV,\n", - " wfdb_root = WFDB_ROOT,\n", - " sampling_rate = SIGNAL_FS,\n", - " )\n", - " ptbxl_ds.stat()\n", - "\n", - " # \u2500\u2500 Stage 2: Apply multilabel task function \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " print()\n", - " samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", - "\n", - " # \u2500\u2500 Stage 3: Split using strat_fold (no patient leakage guaranteed) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " train_s, val_s, test_s = split_by_fold(samples)\n", - " print(f\"\\nStratified split (strat_fold 1-8 / 9 / 10):\")\n", - " print(f\" Train : {len(train_s):,} samples (folds 1-8)\")\n", - " print(f\" Val : {len(val_s):,} samples (fold 9 \u2014 human validated)\")\n", - " print(f\" Test : {len(test_s):,} samples (fold 10 \u2014 human validated)\")\n", - "\n", - " # Patient leakage check\n", - " train_pids = {s[\"patient_id\"] for s in train_s}\n", - " val_pids = {s[\"patient_id\"] for s in val_s}\n", - " test_pids = {s[\"patient_id\"] for s in test_s}\n", - " leakage_tv = len(train_pids & val_pids)\n", - " leakage_tt = len(train_pids & test_pids)\n", - " print(f\"\\n Patient leakage train\u2229val={leakage_tv} train\u2229test={leakage_tt}\"\n", - " f\" {'\u2705 no leakage' if leakage_tv == 0 and leakage_tt == 0 else '\u274c LEAKAGE!'}\")\n", - "\n", - " # \u2500\u2500 Stage 4: Build DataLoaders \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " train_loader_b = get_dataloader(train_s, batch_size=32, shuffle=True)\n", - " val_loader_b = get_dataloader(val_s, batch_size=32, shuffle=False)\n", - " test_loader_b = get_dataloader(test_s, batch_size=32, shuffle=False)\n", - "\n", - " # \u2500\u2500 Verify batch shape \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " sig_b, lbl_b, ids_b = next(iter(train_loader_b))\n", - " print(f\"\\nBatch verification:\")\n", - " print(f\" signals shape : {tuple(sig_b.shape)} \u2192 (batch, leads=12, time=5000 @ 500 Hz)\")\n", - " print(f\" labels shape : {tuple(lbl_b.shape)} \u2192 (batch, 5-class multi-hot)\")\n", - " assert sig_b.shape[1] == 12 and sig_b.shape[2] == 5000, \\\n", - " f\"Unexpected signal shape: {sig_b.shape}. Expected (B, 12, 5000).\"\n", - "\n", - " print(f\"\\n\u2705 Section B pipeline verified with real PTB-XL data!\")\n", - " print(f\" YAML config : ptbxl_v103_pyhealth.yaml\")\n", - " print(f\" Records CSV : {RECORDS_CSV.name}\")\n", - " print(f\" Signal FS : {SIGNAL_FS} Hz \u2192 T=5000 samples/recording\")\n", - " print(f\" Classes : {SUPERDIAG_CLASSES}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "66202ad3", - "metadata": {}, - "source": [ - "\n", - "Following the **HW5 PyHealth pattern**:\n", - "> Dataset \u2192 `set_task()` \u2192 DataLoader \u2192 Model \u2192 Train \u2192 Evaluate\n", - "\n", - "```\n", - "ptbxl-records-pyhealth.csv (built from ptbxl_database.csv in Section B)\n", - " \u2502\n", - " \u25bc\n", - "PTBXLRecordDataset(root, csv) # loads metadata (no signals yet)\n", - " \u2502\n", - " \u25bc .set_task(ptbxl_multilabel_fn)\n", - "PTBXLSampleDataset # each sample = {signal tensor, labels list}\n", - " \u2502\n", - " \u251c\u2500\u2500 split_by_fold(train_folds=1-8, val_fold=9, test_fold=10)\n", - " \u2502 \u251c\u2500\u2500 train (17,084 samples \u2014 folds 1-8)\n", - " \u2502 \u251c\u2500\u2500 val ( 2,146 samples \u2014 fold 9, human-validated)\n", - " \u2502 \u2514\u2500\u2500 test ( 2,158 samples \u2014 fold 10, human-validated)\n", - " \u25bc\n", - "Your model \u2192 trainer.train() \u2192 trainer.evaluate()\n", - "```\n", - "\n", - "### Label space: SNOMED-CT \u2192 5-class superdiagnostic\n", - "\n", - "| Class | Meaning |\n", - "|---|---|\n", - "| `NORM` | Normal sinus rhythm |\n", - "| `MI` | Myocardial infarction |\n", - "| `STTC` | ST/T-change |\n", - "| `CD` | Conduction disturbance |\n", - "| `HYP` | Hypertrophy |\n", - "\n", - "### Key design choices (matching HW4 + HW5 patterns)\n", - "\n", - "- **Stratified fold split** \u2014 `split_by_fold()` uses PTB-XL's `strat_fold` column (available in `ptbxl_database.csv`), guaranteeing zero patient leakage AND that val/test folds (9 & 10) contain only human-validated labels; this is the benchmark-standard split used in the original paper\n", - "- **Lazy signal loading** \u2014 `.mat` files are read only inside the task function, not at dataset init (keeps memory low, mirrors HW5's design)\n", - "- **Custom `collate_fn`** \u2014 batches signals as `(B, 12, T)` tensors exactly like HW4's `my_collate` that stacks channel dim before batch dim\n", - "- **Full 500 Hz signal** \u2014 Section B keeps the native 5000-sample signal `(12, 5000)` at 500 Hz; Section A decimates to 100 Hz `(12, 1000)` for speed" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4c7771e3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset / task helpers ready.\n" - ] - } - ], - "source": [ - "import scipy.io\n", - "import numpy as np\n", - "import torch\n", - "from collections import defaultdict\n", - "from torch.utils.data import Dataset, DataLoader\n", - "from pathlib import Path\n", - "from typing import Optional\n", - "import pandas as pd\n", - "\n", - "\n", - "# \u2500\u2500 SNOMED-CT \u2192 5-class superdiagnostic mapping \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Exact map from pyhealth/tasks/ptbxl_multilabel_classification.py (jtwells2)\n", - "SNOMED_TO_SUPERDIAG = {\n", - " # NORM\n", - " '426783006': 'NORM',\n", - " # MI \u2014 9 codes\n", - " '57054005': 'MI', # Acute myocardial infarction\n", - " '164865005': 'MI', # Myocardial infarction\n", - " '413444003': 'MI', # Acute MI of anterolateral wall\n", - " '413867000': 'MI', # Acute MI of inferior wall\n", - " '164861001': 'MI', # Anterior MI\n", - " '164857002': 'MI', # Inferior MI\n", - " '164860000': 'MI', # Anteroseptal MI\n", - " '164864009': 'MI', # Posterior MI\n", - " '164867002': 'MI', # Lateral MI\n", - " # STTC \u2014 7 codes\n", - " '164931005': 'STTC', # ST elevation\n", - " '164934002': 'STTC', # ST depression\n", - " '59931005': 'STTC', # T-wave abnormality\n", - " '164947007': 'STTC', # Prolonged PR interval\n", - " '164917005': 'STTC', # Prolonged QT interval\n", - " '251268003': 'STTC', # Early repolarisation pattern\n", - " '428750005': 'STTC', # Non-specific ST-T change\n", - " # CD \u2014 21 codes\n", - " '270492004': 'CD', # First-degree AV block\n", - " '195042002': 'CD', # Second-degree AV block\n", - " '27885002': 'CD', # Third-degree AV block\n", - " '6374002': 'CD', # Bundle branch block (unspecified)\n", - " '713427006': 'CD', # Complete right bundle branch block\n", - " '713426002': 'CD', # Complete left bundle branch block\n", - " '164909002': 'CD', # Left bundle branch block\n", - " '59118001': 'CD', # Right bundle branch block\n", - " '698252002': 'CD', # Non-specific intraventricular conduction disturbance\n", - " '445118002': 'CD', # Left anterior fascicular block\n", - " '10370003': 'CD', # Pacing rhythm\n", - " '164889003': 'CD', # Atrial fibrillation\n", - " '164890007': 'CD', # Atrial flutter\n", - " '426627000': 'CD', # Bradycardia\n", - " '427393009': 'CD', # Sinus arrhythmia\n", - " '426177001': 'CD', # Sinus bradycardia\n", - " '427084000': 'CD', # Sinus tachycardia\n", - " '63593006': 'CD', # Supraventricular premature beats\n", - " '17338001': 'CD', # Ventricular premature beats\n", - " '284470004': 'CD', # Premature atrial contraction\n", - " '427172004': 'CD', # Premature ventricular contraction\n", - " # HYP \u2014 8 codes\n", - " '55827005': 'HYP', # Left ventricular hypertrophy\n", - " '446358003': 'HYP', # Right ventricular hypertrophy\n", - " '73282002': 'HYP', # Biventricular hypertrophy\n", - " '67751000119106': 'HYP', # Left atrial enlargement\n", - " '446813000': 'HYP', # Right atrial enlargement\n", - " '39732003': 'HYP', # Left axis deviation\n", - " '47665007': 'HYP', # Right axis deviation\n", - " '251146004': 'HYP', # Low QRS voltage\n", - "}\n", - "SUPERDIAG_CLASSES = ['NORM', 'MI', 'STTC', 'CD', 'HYP']\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Stage 1 \u2014 PTBXLRecordDataset (mirrors HW5 MIMIC3Dataset)\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLRecordDataset:\n", - " \"\"\"\n", - " Wraps ptbxl-pyhealth.csv as a PyHealth-compatible dataset object.\n", - "\n", - " HW5 analogy\n", - " -----------\n", - " MIMIC3Dataset(root, tables, code_mapping) -> PTBXLRecordDataset(root, csv)\n", - " dataset.set_task(fn) -> ds.set_task(ptbxl_multilabel_fn)\n", - " \"\"\"\n", - "\n", - " def __init__(self, root: Path, csv: Path, sampling_rate: int = 100):\n", - " self.root = Path(root)\n", - " self.sampling_rate = sampling_rate\n", - " self._df = pd.read_csv(csv)\n", - " self.patients = {row['patient_id']: row.to_dict()\n", - " for _, row in self._df.iterrows()}\n", - " print(f\"[PTBXLRecordDataset] {len(self.patients):,} records loaded \"\n", - " f\"from {csv.name} @ {sampling_rate} Hz target\")\n", - "\n", - " def stat(self):\n", - " df = self._df\n", - " print('=' * 55)\n", - " print(' PTBXLRecordDataset statistics')\n", - " print('=' * 55)\n", - " print(f\" Records : {len(df):,}\")\n", - " print(f\" Groups : {df['group'].nunique()}\")\n", - " unique_codes = {c.strip()\n", - " for codes in df['scp_codes'].dropna()\n", - " for c in str(codes).split(',')}\n", - " print(f\" Unique Dx codes : {len(unique_codes)}\")\n", - " print('=' * 55)\n", - "\n", - " def set_task(self, task_fn) -> 'PTBXLSampleDataset':\n", - " \"\"\"Apply a task function to every record and return a SampleDataset.\"\"\"\n", - " samples = []\n", - " for pid, record in self.patients.items():\n", - " result = task_fn(record, root=self.root,\n", - " sampling_rate=self.sampling_rate)\n", - " if result is not None:\n", - " samples.append(result)\n", - " skipped = len(self.patients) - len(samples)\n", - " print(f\"[set_task] {len(samples):,} samples generated \"\n", - " f\"({skipped} skipped - no mappable label)\")\n", - " return PTBXLSampleDataset(samples)\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Stage 2 \u2014 Task function\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "def ptbxl_multilabel_fn(\n", - " record: dict,\n", - " root: Path,\n", - " sampling_rate: int = 100,\n", - ") -> Optional[dict]:\n", - " \"\"\"\n", - " Convert one metadata dict into a sample dict.\n", - " Change 4: stores mat_path only - signal loaded lazily in __getitem__.\n", - " Change 3: uses exact jtwells2 SNOMED map (46 codes).\n", - " Returns None if signal file is missing or no label mapped.\n", - " \"\"\"\n", - " mat_path = Path(root) / record['signal_file']\n", - " if not mat_path.exists():\n", - " return None\n", - "\n", - " # Map Dx codes -> superdiagnostic labels\n", - " codes = [c.strip() for c in str(record.get('scp_codes', '')).split(',') if c.strip()]\n", - " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", - " if not labels:\n", - " return None\n", - "\n", - " label_vec = np.zeros(len(SUPERDIAG_CLASSES), dtype=np.float32)\n", - " for lbl in labels:\n", - " label_vec[SUPERDIAG_CLASSES.index(lbl)] = 1.0\n", - "\n", - " return {\n", - " 'patient_id': record['patient_id'],\n", - " 'record_id': record['record_id'],\n", - " 'mat_path': str(mat_path), # Change 4: path only; signal loaded in __getitem__\n", - " 'sampling_rate': sampling_rate,\n", - " 'labels': labels,\n", - " 'label_vec': label_vec,\n", - " 'age': record.get('age'),\n", - " 'sex': record.get('sex'),\n", - " }\n", - "\n", - "\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "# Stage 3 \u2014 SampleDataset + DataLoader helpers\n", - "# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "class PTBXLSampleDataset(Dataset):\n", - " \"\"\"\n", - " Lazy-loading Dataset: signals are read from disk in __getitem__.\n", - " Change 4: no signal arrays stored in memory - O(metadata) RAM only.\n", - " Change 2: ADC -> mV normalization (/ 200.0) applied on load.\n", - " \"\"\"\n", - "\n", - " def __init__(self, samples: list):\n", - " self.samples = samples\n", - "\n", - " def __len__(self):\n", - " return len(self.samples)\n", - "\n", - " def __getitem__(self, idx: int):\n", - " s = self.samples[idx]\n", - " # Change 4: lazy load from disk per-batch request\n", - " mat = scipy.io.loadmat(s['mat_path'])\n", - " # Change 2: ADC counts -> millivolts (gain = 200 LSB/mV for PTB-XL)\n", - " signal = mat['val'].astype(np.float32) / 200.0 # (12, 5000)\n", - " if s['sampling_rate'] == 100:\n", - " signal = signal[:, ::5] # (12, 5000) -> (12, 1000)\n", - " return {\n", - " 'signal': torch.from_numpy(signal),\n", - " 'label_vec': torch.from_numpy(s['label_vec']),\n", - " 'labels': s['labels'],\n", - " }\n", - "\n", - " def stat(self):\n", - " from collections import Counter\n", - " cnt = Counter(lbl for s in self.samples for lbl in s['labels'])\n", - " print(f'Total samples : {len(self.samples):,}')\n", - " print('Label distribution:')\n", - " for cls in SUPERDIAG_CLASSES:\n", - " n = cnt.get(cls, 0)\n", - " print(f' {cls:5s}: {n:5d} ({n/len(self.samples)*100:.1f}%)')\n", - "\n", - "\n", - "def split_by_patient(\n", - " dataset: PTBXLSampleDataset,\n", - " ratios=(0.8, 0.1, 0.1),\n", - " seed: int = 42,\n", - "):\n", - " \"\"\"\n", - " Change 1: patient-level split - guarantees zero cross-split patient leakage.\n", - " Replaces split_by_sample which could put the same patient in train and test.\n", - " \"\"\"\n", - " patient_buckets = defaultdict(list)\n", - " for i, s in enumerate(dataset.samples):\n", - " patient_buckets[s['patient_id']].append(i)\n", - "\n", - " pids = list(patient_buckets.keys())\n", - " rng = np.random.default_rng(seed)\n", - " rng.shuffle(pids)\n", - "\n", - " n = len(pids)\n", - " n_train = int(ratios[0] * n)\n", - " n_val = int(ratios[1] * n)\n", - "\n", - " train_idx = [i for pid in pids[:n_train] for i in patient_buckets[pid]]\n", - " val_idx = [i for pid in pids[n_train:n_train + n_val] for i in patient_buckets[pid]]\n", - " test_idx = [i for pid in pids[n_train + n_val:] for i in patient_buckets[pid]]\n", - "\n", - " return (\n", - " PTBXLSampleDataset([dataset.samples[i] for i in train_idx]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in val_idx]),\n", - " PTBXLSampleDataset([dataset.samples[i] for i in test_idx]),\n", - " )\n", - "\n", - "\n", - "def get_dataloader(\n", - " dataset: PTBXLSampleDataset,\n", - " batch_size: int = 32,\n", - " shuffle: bool = False,\n", - ") -> DataLoader:\n", - " \"\"\"Wrap dataset in a DataLoader with a custom collate (mirrors HW5).\"\"\"\n", - " def collate_fn(batch):\n", - " return {\n", - " 'signal': torch.stack([b['signal'] for b in batch]), # (B,12,T)\n", - " 'label_vec': torch.stack([b['label_vec'] for b in batch]), # (B,5)\n", - " 'labels': [b['labels'] for b in batch],\n", - " }\n", - " return DataLoader(dataset, batch_size=batch_size,\n", - " shuffle=shuffle, collate_fn=collate_fn)\n", - "\n", - "\n", - "print('Dataset / task helpers ready (all 4 improvements applied).')\n", - "print(' Change 1: split_by_patient() - zero patient leakage (was split_by_sample)')\n", - "print(' Change 2: ADC / 200.0 - millivolt normalization in __getitem__')\n", - "print(' Change 3: 46-code SNOMED map - exact jtwells2 map from ptbxl_multilabel_classification.py')\n", - "print(' Change 4: lazy signal loading - mat_path stored; signal read per-batch')\n", - "print(f' Map size: {len(SNOMED_TO_SUPERDIAG)} codes -> {len(SUPERDIAG_CLASSES)} classes')" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "5f4bd892", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[PTBXLRecordDataset] 21,837 records loaded from ptbxl-pyhealth.csv @ 100 Hz target\n", - "=======================================================\n", - " PTBXLRecordDataset statistics\n", - "=======================================================\n", - " Records : 21,837\n", - " Groups : 22\n", - " Unique Dx codes : 50\n", - "=======================================================\n", - "\n", - "[set_task] 21,666 samples generated (171 skipped \u2014 no mappable label)\n", - "Total samples : 21,666\n", - "Label distribution:\n", - " NORM : 18092 (83.5%)\n", - " MI : 6395 (29.5%)\n", - " STTC : 4550 (21.0%)\n", - " CD : 5626 (26.0%)\n", - " HYP : 2587 (11.9%)\n", - "\n", - "Splits \u2192 train: 15,166 | val: 2,166 | test: 4,334\n", - "Batches / epoch: 474\n", - "\n", - "One training batch:\n", - " signal shape : (32, 12, 1000) = (batch, 12 leads, 1000 samples)\n", - " label_vec shape : (32, 5) = (batch, 5 classes)\n", - " classes present : ['CD', 'HYP', 'MI', 'NORM', 'STTC']\n", - "\n", - "Stage 4 \u2192 Plug train_loader / val_loader into your model + Trainer.\n", - "Stage 5 \u2192 trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro\n", - "(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)\n" - ] - } - ], - "source": [ - "# \u2500\u2500 Full 5-stage pipeline run (HW5 style) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "\n", - "# Stage 1: Dataset\n", - "ptbxl_ds = PTBXLRecordDataset(\n", - " root=PTBXL_CHALLENGE_ROOT,\n", - " csv=CSV_OUTPUT_PATH,\n", - " sampling_rate=100, # 100 Hz \u2014 target (decimated from 500 Hz native)\n", - ")\n", - "ptbxl_ds.stat()\n", - "print()\n", - "\n", - "# Stage 2: Task\n", - "ptbxl_samples = ptbxl_ds.set_task(ptbxl_multilabel_fn)\n", - "ptbxl_samples.stat()\n", - "print()\n", - "\n", - "# Stage 3: Split + DataLoaders (matches HW5 Section 2 split code)\n", - "train_ds, val_ds, test_ds = split_by_sample(ptbxl_samples, ratios=(0.7, 0.1, 0.2))\n", - "train_loader = get_dataloader(train_ds, batch_size=32, shuffle=True)\n", - "val_loader = get_dataloader(val_ds, batch_size=32, shuffle=False)\n", - "test_loader = get_dataloader(test_ds, batch_size=32, shuffle=False)\n", - "\n", - "print(f'Splits \u2192 train: {len(train_ds):,} | val: {len(val_ds):,} | test: {len(test_ds):,}')\n", - "print(f'Batches / epoch: {len(train_loader)}')\n", - "print()\n", - "\n", - "# \u2500\u2500 Verify one batch (HW4-style shape check) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - "batch = next(iter(train_loader))\n", - "print('One training batch:')\n", - "print(f\" signal shape : {tuple(batch['signal'].shape)} \"\n", - " f\"= (batch, 12 leads, {batch['signal'].shape[2]} samples)\")\n", - "print(f\" label_vec shape : {tuple(batch['label_vec'].shape)} \"\n", - " f\"= (batch, 5 classes)\")\n", - "print(f\" classes present : {sorted({l for lbls in batch['labels'] for l in lbls})}\")\n", - "print()\n", - "print('Stage 4 \u2192 Plug train_loader / val_loader into your model + Trainer.')\n", - "print('Stage 5 \u2192 trainer.evaluate(test_loader) \u2192 roc_auc_macro, f1_macro')\n", - "print('(See examples/ptbxl_superdiagnostic_sparcnet.ipynb for the full loop)')\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.9.6)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/cs598_project/se_resnet_ecg_pipeline.ipynb b/cs598_project/se_resnet_ecg_pipeline.ipynb deleted file mode 100644 index 9ae0e6c8a..000000000 --- a/cs598_project/se_resnet_ecg_pipeline.ipynb +++ /dev/null @@ -1,871 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "db00a8ba", - "metadata": {}, - "source": [ - "# SE-ResNet ECG — Comparative Study\n", - "\n", - "**CS-598 DLH Project · April 2026**\n", - "\n", - "This notebook implements and evaluates **SE-ResNet-50** (Squeeze-Excitation ResNet) as proposed in:\n", - "\n", - "> Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural Network Architectures for ECG Diagnosis.* MLHC 2021.\n", - "\n", - "**Goal:** Reproduce the paper's SE-ResNet-50 architecture within the PyHealth framework and compare it against the two baselines from `ptbxl_pyhealth_pipeline.ipynb` using the same dataset, splits, and evaluation protocol.\n", - "\n", - "| Model | Architecture | Source |\n", - "|---|---|---|\n", - "| **SE-ResNet-50** | ResNet-50 1D + Squeeze-Excitation blocks | `se_resnet_ecg.py` (this study) |\n", - "| **SparcNet** | DenseNet-inspired 1D TCN | PyHealth built-in |\n", - "| **BiLSTMECG** | Bidirectional LSTM, 1 layer, hidden=64 | `PyHealth/pyhealth/models/bilstm_ecg.py` |\n", - "\n", - "---\n", - "\n", - "### SE-ResNet architecture (paper §4.2 + Appendix A.3)\n", - "\n", - "```\n", - "Input (B, 12, T) — 12 ECG leads × T samples\n", - " → Conv1d(12, 64, k=7, s=2) → BN → ReLU → MaxPool1d(k=3, s=2)\n", - " → Stage 1: 3 × Bottleneck1D(256) + SE\n", - " → Stage 2: 4 × Bottleneck1D(512) + SE [stride=2]\n", - " → Stage 3: 6 × Bottleneck1D(1024) + SE [stride=2]\n", - " → Stage 4: 3 × Bottleneck1D(2048) + SE [stride=2]\n", - " → AdaptiveAvgPool1d(1) → Flatten (B, 2048)\n", - " → Neck: Linear(2048 → 256) (paper: all backbones output 256-dim)\n", - " → Head: FC(256) → ReLU → BN → Dropout(0.5) → FC(K)\n", - " → BCEWithLogitsLoss (multi-label)\n", - "```\n", - "\n", - "**SE Block** (Hu et al., 2018 — Squeeze-and-Excitation Networks):\n", - "- *Squeeze*: ``AdaptiveAvgPool1d(1)`` → ``(B, C)``\n", - "- *Excitation*: ``Linear(C, C//16) → ReLU → Linear(C//16, C) → Sigmoid``\n", - "- *Scale*: element-wise multiply channel weights onto the feature map\n", - "\n", - "Best hyperparams from paper grid search:\n", - "- SE-ResNet-50, **lr = 0.01**, **batch = 64** → ROC-AUC = 0.9082 on PTB-XL `all`\n", - "\n", - "---\n", - "### ⚡ Execution guide\n", - "Run all cells top-to-bottom. Cells 3–6 reuse the pickle cache created by\n", - "`ptbxl_pyhealth_pipeline.ipynb` if it was run first; otherwise they rebuild\n", - "the cache (~2 min). The training cells use `N_SUBSAMPLE=2000` / 3 epochs for\n", - "speed. Change `N_SUBSAMPLE` and `TRAIN_EPOCHS` at the top of their cells for\n", - "publication-quality results." - ] - }, - { - "cell_type": "markdown", - "id": "71ad6c27", - "metadata": {}, - "source": [ - "---\n", - "## Cell 1 — Imports and device" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9185b745", - "metadata": {}, - "outputs": [], - "source": [ - "# ── Standard library & scientific stack ──────────────────────────────────────\n", - "import ast\n", - "import os\n", - "import pickle\n", - "import sys\n", - "import warnings\n", - "from collections import defaultdict\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "import torch.nn as nn\n", - "from sklearn.metrics import roc_auc_score, f1_score, roc_curve\n", - "\n", - "# ── PyHealth ──────────────────────────────────────────────────────────────────\n", - "from pyhealth.datasets import (\n", - " BaseSignalDataset,\n", - " SampleSignalDataset,\n", - " get_dataloader,\n", - " split_by_patient,\n", - ")\n", - "import pyhealth.datasets as _ph_ds\n", - "from pyhealth.models import BaseModel, SparcNet\n", - "from pyhealth.trainer import Trainer\n", - "from pyhealth.metrics import multilabel_metrics_fn\n", - "\n", - "# ── SE-ResNet-50 model (defined in se_resnet_ecg.py, same folder) ─────────────\n", - "_CS598_DIR = Path(\".\").resolve()\n", - "if str(_CS598_DIR) not in sys.path:\n", - " sys.path.insert(0, str(_CS598_DIR))\n", - "from se_resnet_ecg import SEResNetECG\n", - "\n", - "# ── BiLSTMECG (from PyHealth models folder) ───────────────────────────────────\n", - "_PYHEALTH_MODELS = _CS598_DIR.parent / \"pyhealth\" / \"models\"\n", - "if str(_PYHEALTH_MODELS) not in sys.path:\n", - " sys.path.insert(0, str(_PYHEALTH_MODELS))\n", - "from bilstm_ecg import BiLSTMECG\n", - "\n", - "from scipy.io import loadmat as scipy_loadmat\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning, module=\"dask\")\n", - "\n", - "# ── Device ────────────────────────────────────────────────────────────────────\n", - "DEVICE = (\n", - " \"mps\" if torch.backends.mps.is_available() else\n", - " \"cuda\" if torch.cuda.is_available() else\n", - " \"cpu\"\n", - ")\n", - "\n", - "print(\"✅ All imports successful\")\n", - "print(f\" PyTorch : {torch.__version__}\")\n", - "print(f\" Device : {DEVICE}\")\n", - "try:\n", - " import pyhealth; print(f\" PyHealth : {pyhealth.__version__}\")\n", - "except Exception:\n", - " print(\" PyHealth : (version not exposed)\")\n", - "print(f\" SEResNetECG from : {Path(SEResNetECG.__module__.replace('.', '/') + '.py').name}\")" - ] - }, - { - "cell_type": "markdown", - "id": "e35c780a", - "metadata": {}, - "source": [ - "---\n", - "## Cell 2 — Dataset setup\n", - "\n", - "Identical to `ptbxl_pyhealth_pipeline.ipynb` Cells 3–5. Reuses the\n", - "`ptbxl-pyhealth.csv` metadata file if already present." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23762fdd", - "metadata": {}, - "outputs": [], - "source": [ - "# ── Paths ────────────────────────────────────────────────────────────────────\n", - "_PROJECT_ROOT = Path(\"/Users/anuragd/CS-598_HealthCareAssignment/DLH_Project/PyHealth/cs598_project\")\n", - "CINC_PTBXL_ROOT = (\n", - " _PROJECT_ROOT.parent.parent /\n", - " \"classification-of-12-lead-ecgs-the-physionetcomputing-in-cardiology-challenge-2020-1.0.2\"\n", - " / \"training\" / \"ptb-xl\"\n", - ")\n", - "print(f\"CinC PTB-XL root : {CINC_PTBXL_ROOT}\")\n", - "assert CINC_PTBXL_ROOT.exists(), f\"Data not found at {CINC_PTBXL_ROOT}\"\n", - "\n", - "# ── prepare_metadata() — same as main pipeline ────────────────────────────────\n", - "def prepare_metadata(root: Path) -> Path:\n", - " \"\"\"Scan g*/ .hea files → write ptbxl-pyhealth.csv (jtwells2 logic).\"\"\"\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth\" / \"ptbxl\"\n", - " shared_csv = root / \"ptbxl-pyhealth.csv\"\n", - " cache_csv = cache_dir / \"ptbxl-pyhealth.csv\"\n", - " if shared_csv.exists():\n", - " print(f\" CSV found: {shared_csv}\"); return shared_csv\n", - " if cache_csv.exists():\n", - " print(f\" CSV cache: {cache_csv}\"); return cache_csv\n", - " rows = []\n", - " for gdir in sorted(root.glob(\"g*/\")):\n", - " if not gdir.is_dir(): continue\n", - " for hea in sorted(gdir.glob(\"*.hea\")):\n", - " mat = hea.with_suffix(\".mat\")\n", - " if not mat.exists(): continue\n", - " rid = hea.stem\n", - " age, sex, scp_codes = None, None, \"\"\n", - " for raw in hea.read_text(encoding=\"utf-8\", errors=\"replace\").splitlines():\n", - " line = raw.strip()\n", - " if line.startswith(\"# Age:\"):\n", - " try: age = int(float(line.split(\":\", 1)[-1].strip()))\n", - " except: pass\n", - " elif line.startswith(\"# Sex:\"): sex = line.split(\":\", 1)[-1].strip()\n", - " elif line.startswith(\"# Dx:\"): scp_codes = line.split(\":\", 1)[-1].strip()\n", - " rows.append({\"patient_id\": rid, \"record_id\": rid,\n", - " \"signal_file\": str(mat.absolute()),\n", - " \"age\": age, \"sex\": sex, \"scp_codes\": scp_codes,\n", - " \"sampling_rate\": 500, \"num_samples\": 5000,\n", - " \"num_leads\": 12, \"group\": gdir.name})\n", - " if not rows:\n", - " raise RuntimeError(f\"No .hea files found under {root}\")\n", - " df = pd.DataFrame(rows).sort_values(\"patient_id\").reset_index(drop=True)\n", - " try:\n", - " df.to_csv(shared_csv, index=False); return shared_csv\n", - " except (PermissionError, OSError):\n", - " cache_dir.mkdir(parents=True, exist_ok=True)\n", - " df.to_csv(cache_csv, index=False); return cache_csv\n", - "\n", - "csv_path = prepare_metadata(CINC_PTBXL_ROOT)\n", - "df_meta = pd.read_csv(csv_path)\n", - "print(f\" Metadata: {df_meta.shape[0]:,} records\")\n", - "\n", - "# ── PTBXLDataset (BaseSignalDataset adapter — jtwells2 schema) ────────────────\n", - "class PTBXLDataset(BaseSignalDataset):\n", - " def __init__(self, csv_path, **kwargs):\n", - " self._csv_path = Path(csv_path)\n", - " super().__init__(root=str(self._csv_path.parent),\n", - " dataset_name=\"ptbxl\", **kwargs)\n", - " def process_EEG_data(self):\n", - " df = pd.read_csv(self._csv_path)\n", - " patients = defaultdict(list)\n", - " for _, row in df.iterrows():\n", - " pid = str(row[\"patient_id\"])\n", - " patients[pid].append({\n", - " \"patient_id\": pid, \"ecg_id\": str(row[\"record_id\"]),\n", - " \"mat_path\": str(row[\"signal_file\"]),\n", - " \"scp_codes\": str(row[\"scp_codes\"]) if pd.notna(row[\"scp_codes\"]) else \"\",\n", - " \"age\": row.get(\"age\"), \"sex\": row.get(\"sex\"),\n", - " })\n", - " return dict(patients)\n", - "\n", - "print(\"\\nInitialising PTBXLDataset adapter …\")\n", - "dataset = PTBXLDataset(csv_path=str(csv_path))\n", - "print(f\" Total records in dataset : {sum(len(v) for v in dataset.patients.values()):,}\")" - ] - }, - { - "cell_type": "markdown", - "id": "da3e2620", - "metadata": {}, - "source": [ - "---\n", - "## Cell 3 — Task function: PTB-XL superdiagnostic (5 classes)\n", - "\n", - "Same SNOMED_TO_SUPERDIAG mapping and task logic as the main pipeline.\n", - "Pickle cache is reused if present." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e227cc30", - "metadata": {}, - "outputs": [], - "source": [ - "# ── SNOMED → superdiagnostic class mapping (jtwells2 :: ptbxl_multilabel_classification.py) ──\n", - "SNOMED_TO_SUPERDIAG = {\n", - " \"426783006\": \"NORM\",\n", - " \"57054005\": \"MI\", \"164865005\": \"MI\", \"413444003\": \"MI\", \"413867000\": \"MI\",\n", - " \"164861001\": \"MI\", \"164857002\": \"MI\", \"164860000\": \"MI\", \"164864009\": \"MI\",\n", - " \"164867002\": \"MI\",\n", - " \"164931005\": \"STTC\", \"164934002\": \"STTC\", \"59931005\": \"STTC\", \"164947007\": \"STTC\",\n", - " \"164917005\": \"STTC\", \"251268003\": \"STTC\", \"428750005\": \"STTC\",\n", - " \"270492004\": \"CD\", \"195042002\": \"CD\", \"27885002\": \"CD\", \"6374002\": \"CD\",\n", - " \"713427006\": \"CD\", \"713426002\": \"CD\", \"164909002\": \"CD\", \"59118001\": \"CD\",\n", - " \"698252002\": \"CD\", \"445118002\": \"CD\", \"10370003\": \"CD\", \"164889003\": \"CD\",\n", - " \"164890007\": \"CD\", \"426627000\": \"CD\", \"427393009\": \"CD\", \"426177001\": \"CD\",\n", - " \"427084000\": \"CD\", \"63593006\": \"CD\", \"17338001\": \"CD\", \"284470004\": \"CD\",\n", - " \"427172004\": \"CD\",\n", - " \"55827005\": \"HYP\", \"446358003\": \"HYP\", \"73282002\": \"HYP\",\n", - " \"67751000119106\": \"HYP\", \"446813000\": \"HYP\", \"39732003\": \"HYP\",\n", - " \"47665007\": \"HYP\", \"251146004\": \"HYP\",\n", - "}\n", - "SUPERDIAG_CLASSES = [\"NORM\", \"MI\", \"STTC\", \"CD\", \"HYP\"]\n", - "\n", - "# ── Task function — mirrors jtwells2 PTBXLMultilabelClassification.__call__() ─\n", - "def ptbxl_superdiagnostic_fn(record_list, sampling_rate=100, native_freq=500):\n", - " samples = []\n", - " decimate = native_freq // sampling_rate\n", - " expected = 5000 // decimate\n", - " cache_dir = Path.home() / \".cache\" / \"pyhealth_ptbxl\" / f\"cinc_{sampling_rate}hz\"\n", - " cache_dir.mkdir(parents=True, exist_ok=True)\n", - " for visit in record_list:\n", - " pid = visit[\"patient_id\"]\n", - " ecg_id = visit[\"ecg_id\"]\n", - " raw = str(visit[\"scp_codes\"])\n", - " codes = [c.strip() for c in raw.split(\",\") if c.strip()]\n", - " labels = list({SNOMED_TO_SUPERDIAG[c] for c in codes if c in SNOMED_TO_SUPERDIAG})\n", - " if not labels: continue\n", - " mat_path = visit[\"mat_path\"]\n", - " if mat_path and Path(mat_path).exists():\n", - " mat = scipy_loadmat(mat_path)\n", - " signal = mat[\"val\"].astype(np.float32) / 200.0\n", - " else:\n", - " t = np.linspace(0, 10, native_freq * 10)\n", - " lead = 0.5*np.sin(2*np.pi*1.2*t) + np.random.randn(native_freq*10)*0.04\n", - " signal = np.tile(lead, (12, 1)).astype(np.float32)\n", - " signal = signal[:, ::decimate]\n", - " if signal.shape[1] < expected: continue\n", - " pkl_path = str(cache_dir / f\"{ecg_id}.pkl\")\n", - " if not Path(pkl_path).exists():\n", - " with open(pkl_path, \"wb\") as f:\n", - " pickle.dump({\"signal\": signal}, f)\n", - " samples.append({\"patient_id\": pid, \"record_id\": ecg_id,\n", - " \"ecg_id\": ecg_id, \"epoch_path\": pkl_path, \"labels\": labels})\n", - " return samples\n", - "\n", - "print(\"Building SampleSignalDataset (uses cached pickles if available) …\")\n", - "sample_dataset = dataset.set_task(ptbxl_superdiagnostic_fn)\n", - "sample_dataset.input_info[\"labels\"] = {\"type\": str, \"dim\": 2}\n", - "\n", - "n_total = len(sample_dataset)\n", - "print(f\" Total samples : {n_total:,} (one per ECG recording)\")\n", - "print(f\" input_info : {sample_dataset.input_info}\")\n", - "\n", - "# Label prevalence\n", - "pos_rates = np.zeros(len(SUPERDIAG_CLASSES))\n", - "for s in sample_dataset.samples:\n", - " for cls in s[\"labels\"]:\n", - " if cls in SUPERDIAG_CLASSES:\n", - " pos_rates[SUPERDIAG_CLASSES.index(cls)] += 1\n", - "pos_rates /= max(n_total, 1)\n", - "print(\"\\nLabel prevalence:\")\n", - "for cls, rate in zip(SUPERDIAG_CLASSES, pos_rates):\n", - " print(f\" {cls:<6} {rate*100:5.1f}% {'█'*int(rate*30)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "4fa16683", - "metadata": {}, - "source": [ - "---\n", - "## Cell 4 — Patient-level split + DataLoaders\n", - "\n", - "Same 80/10/10 split with seed=42 as the main pipeline. `N_SUBSAMPLE=2000`\n", - "matches the ultra-fast test in `ptbxl_pyhealth_pipeline.ipynb`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9891d118", - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import DataLoader as _DL, Subset as _Subset\n", - "\n", - "# ⚡ Change to 10_000 or None for publication-quality results\n", - "N_SUBSAMPLE = 2_000\n", - "BATCH_SIZE = 32\n", - "\n", - "n_full = len(sample_dataset.samples)\n", - "rng = np.random.default_rng(seed=42)\n", - "all_idx = sorted(\n", - " rng.choice(n_full, size=min(N_SUBSAMPLE, n_full), replace=False).tolist()\n", - ") if N_SUBSAMPLE and N_SUBSAMPLE < n_full else list(range(n_full))\n", - "print(f\"⚡ Working with {len(all_idx):,} records \"\n", - " f\"({'subsampled' if len(all_idx) < n_full else 'full dataset'}, seed=42).\")\n", - "\n", - "# Patient-level split (80/10/10)\n", - "pid_to_pos = {}\n", - "for pos, idx in enumerate(all_idx):\n", - " pid = sample_dataset.samples[idx][\"patient_id\"]\n", - " pid_to_pos.setdefault(pid, []).append(pos)\n", - "pids = list(pid_to_pos.keys())\n", - "np.random.default_rng(42).shuffle(pids)\n", - "n_p = len(pids)\n", - "n_tr = int(0.80 * n_p)\n", - "n_vl = int(0.10 * n_p)\n", - "tr_pos = [p for pid in pids[:n_tr] for p in pid_to_pos[pid]]\n", - "vl_pos = [p for pid in pids[n_tr:n_tr+n_vl] for p in pid_to_pos[pid]]\n", - "te_pos = [p for pid in pids[n_tr+n_vl:] for p in pid_to_pos[pid]]\n", - "tr_idx = [all_idx[p] for p in tr_pos]\n", - "vl_idx = [all_idx[p] for p in vl_pos]\n", - "te_idx = [all_idx[p] for p in te_pos]\n", - "\n", - "train_ds = _Subset(sample_dataset, tr_idx)\n", - "val_ds = _Subset(sample_dataset, vl_idx)\n", - "test_ds = _Subset(sample_dataset, te_idx)\n", - "\n", - "train_loader = _DL(train_ds, batch_size=BATCH_SIZE, shuffle=True,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "val_loader = _DL(val_ds, batch_size=BATCH_SIZE, shuffle=False,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "test_loader = _DL(test_ds, batch_size=BATCH_SIZE, shuffle=False,\n", - " collate_fn=_ph_ds.collate_fn_dict)\n", - "\n", - "print(f\"\\nPatient-level split (80/10/10, seed=42):\")\n", - "print(f\" Train : {len(tr_idx):>5,} samples | {len(train_loader)} batches\")\n", - "print(f\" Val : {len(vl_idx):>5,} samples\")\n", - "print(f\" Test : {len(te_idx):>5,} samples\")\n", - "print(f\" Batch : {BATCH_SIZE}\")\n", - "\n", - "# Leak check\n", - "tr_pids = {sample_dataset.samples[i][\"patient_id\"] for i in tr_idx}\n", - "vl_pids = {sample_dataset.samples[i][\"patient_id\"] for i in vl_idx}\n", - "te_pids = {sample_dataset.samples[i][\"patient_id\"] for i in te_idx}\n", - "assert not (tr_pids & vl_pids), \"LEAKAGE: train ∩ val!\"\n", - "assert not (tr_pids & te_pids), \"LEAKAGE: train ∩ test!\"\n", - "assert not (vl_pids & te_pids), \"LEAKAGE: val ∩ test!\"\n", - "print(\"\\n✅ Zero patient overlap across splits.\")" - ] - }, - { - "cell_type": "markdown", - "id": "990b0d1e", - "metadata": {}, - "source": [ - "---\n", - "## Cell 5 — Instantiate all three models\n", - "\n", - "All models share the same `dataset`, `feature_keys`, `label_key`, and `mode`\n", - "so PyHealth's `BaseModel` wires loss, label tokenizer, and metrics identically." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ddf36b1a", - "metadata": {}, - "outputs": [], - "source": [ - "# ── Shared kwargs for every model ────────────────────────────────────────────\n", - "_common = dict(\n", - " dataset = sample_dataset,\n", - " feature_keys = [\"signal\"],\n", - " label_key = \"labels\",\n", - " mode = \"multilabel\",\n", - ")\n", - "\n", - "# ── Model A: SparcNet (PyHealth built-in) ─────────────────────────────────────\n", - "sparcnet = SparcNet(**_common)\n", - "n_sparcnet = sum(p.numel() for p in sparcnet.parameters() if p.requires_grad)\n", - "\n", - "# ── Model B: BiLSTMECG (paper best: d1_h64) ───────────────────────────────────\n", - "bilstm = BiLSTMECG(**_common, hidden_size=64, n_layers=1)\n", - "n_bilstm = sum(p.numel() for p in bilstm.parameters() if p.requires_grad)\n", - "\n", - "# ── Model C: SE-ResNet-50 (proposed, paper-aligned) ───────────────────────────\n", - "# Best paper config: lr=0.01, batch=64 (grid search Table 5a, Appendix A.3)\n", - "# Architecture: ResNet-50 1D + SE blocks + backbone_out=256 + dropout=0.5\n", - "se_resnet = SEResNetECG(\n", - " **_common,\n", - " layers = [3, 4, 6, 3], # SE-ResNet-50\n", - " se_reduction = 16,\n", - " backbone_out = 256,\n", - " dropout = 0.5,\n", - ")\n", - "n_se_resnet = sum(p.numel() for p in se_resnet.parameters() if p.requires_grad)\n", - "\n", - "# ── Summary table ─────────────────────────────────────────────────────────────\n", - "print(\"=\" * 68)\n", - "print(\" MODEL SUMMARY\")\n", - "print(\"=\" * 68)\n", - "print(f\" {'Model':<20} {'Params':>10} {'Architecture'}\")\n", - "print(\" \" + \"─\" * 62)\n", - "print(f\" {'SparcNet':<20} {n_sparcnet:>10,} DenseNet-inspired 1D TCN (PyHealth)\")\n", - "print(f\" {'BiLSTMECG (d1_h64)':<20} {n_bilstm:>10,} Bidirectional LSTM, 1 layer, h=64\")\n", - "print(f\" {'SE-ResNet-50':<20} {n_se_resnet:>10,} ResNet-50 1D + SE blocks (proposed)\")\n", - "print(\"=\" * 68)\n", - "print(f\"\\n Input : (B, 12, 1000) — 12 leads × 1000 samples @ 100 Hz\")\n", - "print(f\" Output : (B, {len(SUPERDIAG_CLASSES)}) — {SUPERDIAG_CLASSES}\")\n", - "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", - "\n", - "# Smoke test — verify all three models run a forward pass\n", - "test_batch = next(iter(train_loader))\n", - "with torch.no_grad():\n", - " out_s = sparcnet(**test_batch)\n", - " out_b = bilstm(**test_batch)\n", - " out_se = se_resnet(**test_batch)\n", - "print(f\"\\nSmoke test (batch={BATCH_SIZE}):\")\n", - "print(f\" SparcNet logit={tuple(out_s['logit'].shape)} loss={out_s['loss'].item():.4f}\")\n", - "print(f\" BiLSTMECG logit={tuple(out_b['logit'].shape)} loss={out_b['loss'].item():.4f}\")\n", - "print(f\" SE-ResNet logit={tuple(out_se['logit'].shape)} loss={out_se['loss'].item():.4f}\")\n", - "print(\"\\n✅ All three models forward pass successful.\")" - ] - }, - { - "cell_type": "markdown", - "id": "fe927e41", - "metadata": {}, - "source": [ - "---\n", - "## Cell 6 — Train SE-ResNet-50\n", - "\n", - "Paper best config: **lr = 0.01**, batch = 64 (grid search Table 5a). \n", - "We use batch=32 here to match the baselines. Change `TRAIN_EPOCHS` for\n", - "publication-quality convergence (paper uses 250 with early stopping)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b0213d64", - "metadata": {}, - "outputs": [], - "source": [ - "TRAIN_EPOCHS = 3 # ⚡ ultra-fast test; change to 25+ for quality results\n", - "SE_RESNET_LR = 0.01 # paper best hyperparameter (grid search Table 5a)\n", - "\n", - "print(\"=\" * 60)\n", - "print(f\" Training SE-ResNet-50 [{TRAIN_EPOCHS} epochs, N={len(tr_idx)} samples]\")\n", - "print(f\" lr = {SE_RESNET_LR} (paper best from grid search)\")\n", - "print(\"=\" * 60)\n", - "\n", - "trainer_se = Trainer(\n", - " model = se_resnet,\n", - " metrics = [\"roc_auc_macro\", \"f1_macro\"],\n", - " enable_logging = True,\n", - " output_path = \"./output/se_resnet\",\n", - " exp_name = \"seresnet50_superdiag_5class\",\n", - ")\n", - "\n", - "trainer_se.train(\n", - " train_dataloader = train_loader,\n", - " val_dataloader = val_loader,\n", - " epochs = TRAIN_EPOCHS,\n", - " optimizer_params = {\"lr\": SE_RESNET_LR},\n", - " weight_decay = 1e-4,\n", - " monitor = \"roc_auc_macro\",\n", - " monitor_criterion = \"max\",\n", - " load_best_model_at_last = True,\n", - ")\n", - "\n", - "print(\"\\nSE-ResNet-50 training complete.\")" - ] - }, - { - "cell_type": "markdown", - "id": "3173705b", - "metadata": {}, - "source": [ - "---\n", - "## Cell 7 — Evaluate SE-ResNet-50" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6592fde2", - "metadata": {}, - "outputs": [], - "source": [ - "print(\"=\" * 60)\n", - "print(\" SE-ResNet-50 — Test Set Evaluation\")\n", - "print(\"=\" * 60)\n", - "\n", - "se_scores = trainer_se.evaluate(test_loader)\n", - "print(f\"\\n Test ROC-AUC (macro) : {se_scores['roc_auc_macro']:.4f}\")\n", - "print(f\" Test F1 (macro) : {se_scores['f1_macro']:.4f}\")\n", - "print(f\" Test Loss : {se_scores['loss']:.4f}\")\n", - "\n", - "# Per-class breakdown\n", - "y_true_se, y_prob_se, _ = trainer_se.inference(test_loader)\n", - "\n", - "per_class_auc_se = {}\n", - "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", - " col = y_true_se[:, k]\n", - " if col.sum() > 0 and (1 - col).sum() > 0:\n", - " per_class_auc_se[cls] = roc_auc_score(col, y_prob_se[:, k])\n", - " else:\n", - " per_class_auc_se[cls] = float(\"nan\")\n", - "\n", - "print(f\"\\n Per-class ROC-AUC:\")\n", - "for cls, auc in per_class_auc_se.items():\n", - " bar = \"█\" * int((auc if not np.isnan(auc) else 0) * 20)\n", - " tag = f\"{auc:.4f}\" if not np.isnan(auc) else \" N/A\"\n", - " print(f\" {cls:<6} {tag} {bar}\")\n", - "\n", - "# ROC curves\n", - "colors = [\"#e74c3c\", \"#3498db\", \"#2ecc71\", \"#f39c12\", \"#9b59b6\"]\n", - "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", - "for k, (cls, color) in enumerate(zip(SUPERDIAG_CLASSES, colors)):\n", - " col = y_true_se[:, k]\n", - " if col.sum() > 0 and (1-col).sum() > 0:\n", - " fpr, tpr, _ = roc_curve(col, y_prob_se[:, k])\n", - " axes[0].plot(fpr, tpr, color=color, lw=1.8,\n", - " label=f\"{cls} (AUC={per_class_auc_se[cls]:.3f})\")\n", - "axes[0].plot([0,1],[0,1],\"k--\",lw=1,alpha=0.5,label=\"Random\")\n", - "axes[0].set_title(\"SE-ResNet-50 — Per-class ROC Curves\", fontweight=\"bold\")\n", - "axes[0].set_xlabel(\"False Positive Rate\"); axes[0].set_ylabel(\"True Positive Rate\")\n", - "axes[0].legend(fontsize=9)\n", - "\n", - "per_class_f1_se = {}\n", - "for k, cls in enumerate(SUPERDIAG_CLASSES):\n", - " col = y_true_se[:, k]\n", - " pred = (y_prob_se[:, k] >= 0.5).astype(int)\n", - " per_class_f1_se[cls] = f1_score(col, pred, zero_division=0)\n", - "axes[1].bar(SUPERDIAG_CLASSES, [per_class_f1_se[c] for c in SUPERDIAG_CLASSES],\n", - " color=colors, edgecolor=\"white\")\n", - "for i, (cls, sc) in enumerate(per_class_f1_se.items()):\n", - " axes[1].text(i, sc+0.01, f\"{sc:.3f}\", ha=\"center\", fontsize=9)\n", - "axes[1].set_ylim(0, 1.15)\n", - "axes[1].set_title(\"SE-ResNet-50 — Per-class F1 Score\", fontweight=\"bold\")\n", - "axes[1].set_ylabel(\"F1 Score\")\n", - "plt.tight_layout(); plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f5f6b286", - "metadata": {}, - "source": [ - "---\n", - "## Cell 8 — Train baseline models (SparcNet + BiLSTMECG)\n", - "\n", - "Identical training setup as `ptbxl_pyhealth_pipeline.ipynb` for fair comparison." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7160144", - "metadata": {}, - "outputs": [], - "source": [ - "BASELINE_LR = 1e-3 # matches main pipeline\n", - "\n", - "# ── SparcNet ──────────────────────────────────────────────────────────────────\n", - "print(\"=\" * 60)\n", - "print(f\" Training SparcNet [{TRAIN_EPOCHS} epochs, N={len(tr_idx)}]\")\n", - "print(\"=\" * 60)\n", - "\n", - "trainer_sparcnet = Trainer(\n", - " model=sparcnet, metrics=[\"roc_auc_macro\", \"f1_macro\"],\n", - " enable_logging=True, output_path=\"./output/se_resnet\",\n", - " exp_name=\"sparcnet_cmp_superdiag_5class\",\n", - ")\n", - "trainer_sparcnet.train(\n", - " train_dataloader=train_loader, val_dataloader=val_loader,\n", - " epochs=TRAIN_EPOCHS, optimizer_params={\"lr\": BASELINE_LR},\n", - " weight_decay=1e-4, monitor=\"roc_auc_macro\", monitor_criterion=\"max\",\n", - " load_best_model_at_last=True,\n", - ")\n", - "sparcnet_scores = trainer_sparcnet.evaluate(test_loader)\n", - "print(f\"\\n SparcNet AUC={sparcnet_scores['roc_auc_macro']:.4f} \"\n", - " f\"F1={sparcnet_scores['f1_macro']:.4f}\")\n", - "\n", - "# ── BiLSTMECG ─────────────────────────────────────────────────────────────────\n", - "print()\n", - "print(\"=\" * 60)\n", - "print(f\" Training BiLSTMECG [{TRAIN_EPOCHS} epochs, N={len(tr_idx)}]\")\n", - "print(\"=\" * 60)\n", - "\n", - "trainer_bilstm = Trainer(\n", - " model=bilstm, metrics=[\"roc_auc_macro\", \"f1_macro\"],\n", - " enable_logging=True, output_path=\"./output/se_resnet\",\n", - " exp_name=\"bilstm_cmp_superdiag_5class\",\n", - ")\n", - "trainer_bilstm.train(\n", - " train_dataloader=train_loader, val_dataloader=val_loader,\n", - " epochs=TRAIN_EPOCHS, optimizer_params={\"lr\": BASELINE_LR},\n", - " weight_decay=1e-4, monitor=\"roc_auc_macro\", monitor_criterion=\"max\",\n", - " load_best_model_at_last=True,\n", - ")\n", - "bilstm_scores = trainer_bilstm.evaluate(test_loader)\n", - "print(f\"\\n BiLSTMECG AUC={bilstm_scores['roc_auc_macro']:.4f} \"\n", - " f\"F1={bilstm_scores['f1_macro']:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "c817dc4d", - "metadata": {}, - "source": [ - "---\n", - "## Cell 9 — Three-model comparative results\n", - "\n", - "Side-by-side ROC-AUC and F1 comparison of all three models on the same\n", - "test set, with per-class bar charts for SE-ResNet." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0399ad75", - "metadata": {}, - "outputs": [], - "source": [ - "# ── Summary table ─────────────────────────────────────────────────────────────\n", - "all_scores = {\n", - " \"SparcNet\": sparcnet_scores,\n", - " \"BiLSTMECG\": bilstm_scores,\n", - " \"SE-ResNet-50\": se_scores,\n", - "}\n", - "model_colors = {\"SparcNet\": \"#2196F3\", \"BiLSTMECG\": \"#FF5722\", \"SE-ResNet-50\": \"#4CAF50\"}\n", - "\n", - "print(\"\\n\" + \"=\" * 68)\n", - "print(\" COMPARATIVE RESULTS — 3-Model Ablation\")\n", - "print(f\" Dataset : PTB-XL superdiagnostic (5 classes), N={N_SUBSAMPLE:,}\")\n", - "print(f\" Protocol : Patient-level 80/10/10 split, seed=42, {TRAIN_EPOCHS} epochs\")\n", - "print(\"=\" * 68)\n", - "print(f\" {'Model':<20} {'ROC-AUC (macro)':>15} {'F1 (macro)':>10} {'Loss':>8}\")\n", - "print(\" \" + \"─\" * 60)\n", - "for model_name, sc in all_scores.items():\n", - " auc = sc.get(\"roc_auc_macro\", float(\"nan\"))\n", - " f1 = sc.get(\"f1_macro\", float(\"nan\"))\n", - " loss = sc.get(\"loss\", float(\"nan\"))\n", - " print(f\" {model_name:<20} {auc:>15.4f} {f1:>10.4f} {loss:>8.4f}\")\n", - "print(\"=\" * 68)\n", - "\n", - "auc_vals = [sparcnet_scores[\"roc_auc_macro\"], bilstm_scores[\"roc_auc_macro\"],\n", - " se_scores[\"roc_auc_macro\"]]\n", - "f1_vals = [sparcnet_scores[\"f1_macro\"], bilstm_scores[\"f1_macro\"],\n", - " se_scores[\"f1_macro\"]]\n", - "best = list(all_scores.keys())[int(np.argmax(auc_vals))]\n", - "print(f\"\\n Best model by ROC-AUC : {best}\")\n", - "\n", - "# ── Comparative bar charts ────────────────────────────────────────────────────\n", - "model_names = [\"SparcNet\", \"BiLSTMECG\", \"SE-ResNet-50\"]\n", - "colors_list = [model_colors[m] for m in model_names]\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", - "fig.suptitle(\n", - " f\"3-Model Comparison: SparcNet vs BiLSTMECG vs SE-ResNet-50\\n\"\n", - " f\"PTB-XL superdiagnostic (5 classes) | N={N_SUBSAMPLE:,} samples | \"\n", - " f\"{TRAIN_EPOCHS} epochs\",\n", - " fontsize=11, fontweight=\"bold\"\n", - ")\n", - "\n", - "x = np.arange(len(model_names))\n", - "axes[0].bar(x, auc_vals, color=colors_list, edgecolor=\"white\", width=0.55)\n", - "axes[0].axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=1, label=\"Random\")\n", - "for i, (m, v) in enumerate(zip(model_names, auc_vals)):\n", - " axes[0].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=10, fontweight=\"bold\")\n", - "axes[0].set_xticks(x); axes[0].set_xticklabels(model_names, rotation=10)\n", - "axes[0].set_ylim(0, 1.0); axes[0].set_ylabel(\"ROC-AUC (macro)\", fontsize=11)\n", - "axes[0].set_title(\"Test ROC-AUC\", fontweight=\"bold\")\n", - "axes[0].legend(fontsize=9)\n", - "\n", - "axes[1].bar(x, f1_vals, color=colors_list, edgecolor=\"white\", width=0.55)\n", - "for i, (m, v) in enumerate(zip(model_names, f1_vals)):\n", - " axes[1].text(i, v + 0.005, f\"{v:.4f}\", ha=\"center\", fontsize=10, fontweight=\"bold\")\n", - "axes[1].set_xticks(x); axes[1].set_xticklabels(model_names, rotation=10)\n", - "axes[1].set_ylim(0, 1.0); axes[1].set_ylabel(\"F1 Score (macro)\", fontsize=11)\n", - "axes[1].set_title(\"Test F1 Score\", fontweight=\"bold\")\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig(\"ptbxl_3model_comparison.png\", dpi=150, bbox_inches=\"tight\")\n", - "plt.show()\n", - "print(\"\\nFigure saved → ptbxl_3model_comparison.png\")" - ] - }, - { - "cell_type": "markdown", - "id": "a112e83e", - "metadata": {}, - "source": [ - "---\n", - "## Cell 10 — Per-class comparison across all three models" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "98d771cf", - "metadata": {}, - "outputs": [], - "source": [ - "# Collect per-class AUC for all models\n", - "y_true_sn, y_prob_sn, _ = trainer_sparcnet.inference(test_loader)\n", - "y_true_bl, y_prob_bl, _ = trainer_bilstm.inference(test_loader)\n", - "# SE-ResNet inference already done (y_true_se, y_prob_se)\n", - "\n", - "all_inferences = {\n", - " \"SparcNet\": (y_true_sn, y_prob_sn),\n", - " \"BiLSTMECG\": (y_true_bl, y_prob_bl),\n", - " \"SE-ResNet-50\": (y_true_se, y_prob_se),\n", - "}\n", - "\n", - "# Build per-class AUC table\n", - "per_class_auc_all = {}\n", - "for model_name, (y_true, y_prob) in all_inferences.items():\n", - " per_class_auc_all[model_name] = {}\n", - " for k, cls in enumerate(SUPERDIAG_CLASSES):\n", - " col = y_true[:, k]\n", - " if col.sum() > 0 and (1 - col).sum() > 0:\n", - " per_class_auc_all[model_name][cls] = roc_auc_score(col, y_prob[:, k])\n", - " else:\n", - " per_class_auc_all[model_name][cls] = float(\"nan\")\n", - "\n", - "# Print table\n", - "print(\"Per-class ROC-AUC:\")\n", - "print(f\" {'Class':<8}\", end=\"\")\n", - "for m in all_inferences.keys():\n", - " print(f\" {m:>14}\", end=\"\")\n", - "print()\n", - "print(\" \" + \"─\" * 54)\n", - "for cls in SUPERDIAG_CLASSES:\n", - " print(f\" {cls:<8}\", end=\"\")\n", - " for m in all_inferences.keys():\n", - " v = per_class_auc_all[m][cls]\n", - " print(f\" {v:>14.4f}\" if not np.isnan(v) else f\" {' N/A':>14}\", end=\"\")\n", - " print()\n", - "\n", - "# Grouped bar chart per class\n", - "x = np.arange(len(SUPERDIAG_CLASSES))\n", - "w = 0.25\n", - "fig, ax = plt.subplots(figsize=(12, 5))\n", - "for i, (model_name, color) in enumerate(model_colors.items()):\n", - " vals = [per_class_auc_all[model_name][cls] for cls in SUPERDIAG_CLASSES]\n", - " vals = [0 if np.isnan(v) else v for v in vals]\n", - " ax.bar(x + (i - 1) * w, vals, width=w, label=model_name, color=color, edgecolor=\"white\")\n", - "\n", - "ax.set_xticks(x); ax.set_xticklabels(SUPERDIAG_CLASSES)\n", - "ax.set_ylim(0, 1.1); ax.set_ylabel(\"ROC-AUC\", fontsize=11)\n", - "ax.set_title(\"Per-class ROC-AUC: SparcNet vs BiLSTMECG vs SE-ResNet-50\",\n", - " fontweight=\"bold\")\n", - "ax.axhline(0.5, color=\"grey\", linestyle=\"--\", linewidth=0.8, label=\"Random\")\n", - "ax.legend(fontsize=9)\n", - "plt.tight_layout()\n", - "plt.savefig(\"ptbxl_per_class_auc_3model.png\", dpi=150, bbox_inches=\"tight\")\n", - "plt.show()\n", - "print(\"Figure saved → ptbxl_per_class_auc_3model.png\")" - ] - }, - { - "cell_type": "markdown", - "id": "300cd407", - "metadata": {}, - "source": [ - "---\n", - "## Cell 11 — Reproducibility checklist" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7804f255", - "metadata": {}, - "outputs": [], - "source": [ - "import sys, torch, numpy, sklearn, pandas\n", - "\n", - "print(\"=\" * 60)\n", - "print(\" REPRODUCIBILITY CHECKLIST\")\n", - "print(\"=\" * 60)\n", - "print(f\" Python : {sys.version.split()[0]}\")\n", - "print(f\" PyTorch : {torch.__version__}\")\n", - "print(f\" NumPy : {numpy.__version__}\")\n", - "print(f\" scikit-learn : {sklearn.__version__}\")\n", - "print(f\" pandas : {pandas.__version__}\")\n", - "print(\"-\" * 60)\n", - "print(f\" Random seed : 42\")\n", - "print(f\" N_SUBSAMPLE : {N_SUBSAMPLE:,}\")\n", - "print(f\" TRAIN_EPOCHS : {TRAIN_EPOCHS}\")\n", - "print(f\" Batch size : {BATCH_SIZE} (SE-ResNet paper best: 64)\")\n", - "print(f\" SE-ResNet LR : {SE_RESNET_LR} (paper best from grid search Table 5a)\")\n", - "print(f\" Baseline LR : {BASELINE_LR}\")\n", - "print(f\" Split : 80/10/10 patient-level\")\n", - "print(f\" Loss : BCEWithLogitsLoss (multi-label)\")\n", - "print(f\" Metrics : ROC-AUC macro, F1 macro (thr=0.5)\")\n", - "print(f\" Device : {DEVICE}\")\n", - "print(\"=\" * 60)\n", - "print()\n", - "print(\" SE-ResNet-50 architecture (se_resnet_ecg.py):\")\n", - "print(f\" layers = [3, 4, 6, 3] (ResNet-50)\")\n", - "print(f\" se_reduction = 16 (SE-Net paper default)\")\n", - "print(f\" backbone_out = 256 (per paper: all backbones output 256)\")\n", - "print(f\" dropout = 0.5\")\n", - "print()\n", - "print(\" Reference:\")\n", - "print(\" Nonaka & Seita (2021). In-depth Benchmarking of Deep Neural\")\n", - "print(\" Network Architectures for ECG Diagnosis. MLHC 2021.\")\n", - "print(\"=\" * 60)\n", - "print(\"\\n✅ This notebook is self-contained.\")" - ] - } - ], - "metadata": { - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From b235e2397e6d0cd510f6321d0313849a1e6851f5 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 19 Apr 2026 01:58:55 -0700 Subject: [PATCH 09/10] fix: use comma separator for dx_codes (matches ptbxl.py load_data) --- pyhealth/tasks/ptbxl_multilabel_classification.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyhealth/tasks/ptbxl_multilabel_classification.py b/pyhealth/tasks/ptbxl_multilabel_classification.py index fb2f29dc2..d9f44b22b 100644 --- a/pyhealth/tasks/ptbxl_multilabel_classification.py +++ b/pyhealth/tasks/ptbxl_multilabel_classification.py @@ -346,9 +346,9 @@ def __call__(self, patient: Patient) -> List[Dict]: # ---- 3. Parse SNOMED-CT codes -------------------------------- # Column "ptbxl/dx_codes" → attribute "dx_codes"; values are - # dot-joined by load_data() via ".".join(dx), so split on ".". + # comma-joined by load_data() via ",".join(dx), so split on ",". raw_codes: str = str(getattr(event, "dx_codes", "") or "") - codes = [c.strip() for c in raw_codes.split(".") if c.strip()] + codes = [c.strip() for c in raw_codes.split(",") if c.strip()] # ---- 4. Map to chosen label space --------------------------- if self.label_type == "superdiagnostic": From 6ed6a48b76de0f0bfc3cd6ac7e397cf70c1cec10 Mon Sep 17 00:00:00 2001 From: AnuragD2 Date: Sun, 19 Apr 2026 02:13:07 -0700 Subject: [PATCH 10/10] remove: move ECG models to feature_anuragd2/ecg-models branch (jtwells2 review) --- pyhealth/models/__init__.py | 2 - pyhealth/models/bilstm_ecg.py | 192 --------------- pyhealth/models/se_resnet_ecg.py | 393 ------------------------------- 3 files changed, 587 deletions(-) delete mode 100644 pyhealth/models/bilstm_ecg.py delete mode 100644 pyhealth/models/se_resnet_ecg.py diff --git a/pyhealth/models/__init__.py b/pyhealth/models/__init__.py index 9a959f6aa..5233b1726 100644 --- a/pyhealth/models/__init__.py +++ b/pyhealth/models/__init__.py @@ -1,8 +1,6 @@ from .adacare import AdaCare, AdaCareLayer, MultimodalAdaCare from .agent import Agent, AgentLayer from .base_model import BaseModel -from .bilstm_ecg import BiLSTMECG -from .se_resnet_ecg import SEResNetECG, SEBlock1D, Bottleneck1D from .biot import BIOT from .cnn import CNN, CNNLayer from .concare import ConCare, ConCareLayer diff --git a/pyhealth/models/bilstm_ecg.py b/pyhealth/models/bilstm_ecg.py deleted file mode 100644 index a501735af..000000000 --- a/pyhealth/models/bilstm_ecg.py +++ /dev/null @@ -1,192 +0,0 @@ -"""Bidirectional LSTM for 12-lead ECG multi-label classification. - -This module provides :class:`BiLSTMECG`, a :class:`~pyhealth.models.BaseModel` -subclass implementing the Bidirectional LSTM architecture benchmarked in: - - Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural - Network Architectures for ECG Diagnosis.* Proceedings of Machine Learning - Research 126:1–19, MLHC 2021. - -The paper's best-performing LSTM variant (``lstm_d1_h64``) uses a **single -bidirectional LSTM layer** with ``hidden_size=64``, producing 128-dimensional -hidden states that are projected to the output head. This implementation -follows the same design but exposes ``hidden_size`` and ``n_layers`` as -constructor arguments so it can be used as a drop-in replacement across the -full ablation grid. - -Mathematical framing --------------------- -Given an ECG tensor :math:`X \\in \\mathbb{R}^{B \\times C \\times T}` (batch -size :math:`B`, :math:`C=12` leads, :math:`T` time-steps), the model: - -1. Permutes to :math:`(B, T, C)` for sequence-first processing. -2. Passes through a bidirectional LSTM: - - .. math:: - - h_t = \\text{BiLSTM}(x_t, h_{t-1})\\quad h_t \\in \\mathbb{R}^{B \\times 2H} - -3. Takes the **last** time-step output :math:`h_T \\in \\mathbb{R}^{B \\times 2H}`. -4. Projects with a linear head :math:`W \\in \\mathbb{R}^{2H \\times K}` to produce - logits for :math:`K` classes. -5. Optimises with **binary cross-entropy with logits** (multi-label): - - .. math:: - - \\mathcal{L} = -\\frac{1}{K}\\sum_{k=1}^{K} - \\bigl[y_k \\log \\sigma(\\hat{y}_k) - + (1-y_k)\\log(1-\\sigma(\\hat{y}_k))\\bigr] - -Paper alignment ---------------- -+------------+----------------------------+---------------------------+ -| Paper name | Paper setting | Default in this class | -+============+============================+===========================+ -| lstm_d1_h64| 1 layer, hidden=64 | n_layers=1, hidden_size=64| -+------------+----------------------------+---------------------------+ -| lstm_d3_h128| 3 layers, hidden=128 | n_layers=3, hidden_size=128| -+------------+----------------------------+---------------------------+ - -Signal format expected ----------------------- -``feature_keys=["signal"]`` → each batch element is a ``np.ndarray`` of shape -``(12, T)`` loaded by ``SampleSignalDataset`` from a ``.pkl`` file. :math:`T` -is typically 1000 at 100 Hz or 5000 at 500 Hz. - -Author: - CS-598 DLH Project Team — PyHealth contribution -""" - -from typing import List, Optional - -import numpy as np -import torch -import torch.nn as nn - -from pyhealth.models import BaseModel - - -class BiLSTMECG(BaseModel): - """Bidirectional LSTM ECG classifier. - - Extends :class:`~pyhealth.models.BaseModel` so it integrates seamlessly - with :class:`~pyhealth.trainer.Trainer`, :class:`~pyhealth.datasets.PTBXLDataset`, - and :func:`~pyhealth.metrics.multilabel_metrics_fn`. - - Args: - dataset: A PyHealth ``SampleSignalDataset`` (or ``Subset``) that - exposes ``input_info`` with ``"signal"`` → ``{"n_channels": 12}``. - feature_keys (List[str]): Must be ``["signal"]``. - label_key (str): Key in the sample dict that holds the label list. - Use ``"labels"`` to match ``PTBXLMultilabelClassification`` output. - mode (str): ``"multilabel"`` applies ``BCEWithLogitsLoss``; other modes - are passed through to :class:`~pyhealth.models.BaseModel`. - hidden_size (int): LSTM hidden dimension *per direction*. The - bidirectional output is ``2 × hidden_size``. Paper best variant - uses ``hidden_size=64`` (1 layer). Defaults to ``64``. - n_layers (int): Number of stacked LSTM layers. Paper uses ``1``. - Defaults to ``1``. - dropout (float): Dropout probability applied between LSTM layers - when ``n_layers > 1``. Defaults to ``0.2``. - - Examples: - Paper-aligned variant (lstm_d1_h64):: - - >>> from pyhealth.models import BiLSTMECG - >>> model = BiLSTMECG( - ... dataset=sample_dataset, - ... feature_keys=["signal"], - ... label_key="labels", - ... mode="multilabel", - ... hidden_size=64, - ... n_layers=1, - ... ) - - Deeper variant used in ablation grid:: - - >>> model_deep = BiLSTMECG( - ... dataset=sample_dataset, - ... feature_keys=["signal"], - ... label_key="labels", - ... mode="multilabel", - ... hidden_size=128, - ... n_layers=3, - ... ) - """ - - def __init__( - self, - dataset, - feature_keys: List[str], - label_key: str, - mode: str, - hidden_size: int = 64, - n_layers: int = 1, - dropout: float = 0.2, - **kwargs, - ): - super().__init__( - dataset=dataset, - feature_keys=feature_keys, - label_key=label_key, - mode=mode, - ) - - sig_info = self.dataset.input_info["signal"] - in_channels: int = sig_info["n_channels"] # 12 for standard 12-lead ECG - - self.label_tokenizer = self.get_label_tokenizer() - output_size: int = self.get_output_size(self.label_tokenizer) - - # ── Bidirectional LSTM ──────────────────────────────────────────────── - # Input: (B, T, C) after permute - # Output: (B, T, hidden_size * 2) — bidirectional concatenation - self.lstm = nn.LSTM( - input_size=in_channels, - hidden_size=hidden_size, - num_layers=n_layers, - bidirectional=True, - batch_first=True, - dropout=dropout if n_layers > 1 else 0.0, - ) - - # ── Projection head ─────────────────────────────────────────────────── - # Pool over all time-steps: AdaptiveAvgPool1d(1) → (B, hidden_size*2) - self.pool = nn.AdaptiveAvgPool1d(1) - self.fc = nn.Linear(hidden_size * 2, output_size) - - # ------------------------------------------------------------------ - def forward(self, **kwargs) -> dict: # type: ignore[override] - """Forward pass. - - Keyword args are the collated batch dict from the DataLoader. - The key ``self.feature_keys[0]`` (``"signal"``) holds a list of - ``np.ndarray`` of shape ``(12, T)``. - - Returns: - dict with keys ``"loss"``, ``"y_prob"``, ``"y_true"``, - ``"logit"`` — the standard PyHealth model output contract. - """ - # Stack list[(12,T)] → tensor (B, 12, T) - x = torch.tensor( - np.array(kwargs[self.feature_keys[0]]), - device=self.device, - ).float() - - # (B, 12, T) → (B, T, 12) for sequence-first LSTM with batch_first=True - out, _ = self.lstm(x.permute(0, 2, 1)) # (B, T, hidden*2) - # (B, T, hidden*2) → (B, hidden*2, T) → pool → (B, hidden*2) - # Matches paper bi_lstm.py: AdaptiveAvgPool1d over ALL timesteps - pooled = self.pool(out.permute(0, 2, 1)).squeeze(-1) # (B, hidden*2) - logits = self.fc(pooled) # (B, K) - - y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer) - loss = self.get_loss_function()(logits, y_true) - y_prob = self.prepare_y_prob(logits) - - return { - "loss": loss, - "y_prob": y_prob, - "y_true": y_true, - "logit": logits, - } diff --git a/pyhealth/models/se_resnet_ecg.py b/pyhealth/models/se_resnet_ecg.py deleted file mode 100644 index 714541365..000000000 --- a/pyhealth/models/se_resnet_ecg.py +++ /dev/null @@ -1,393 +0,0 @@ -"""SE-ResNet-50 for 12-lead ECG multi-label classification. - -This module provides :class:`SEResNetECG`, a :class:`~pyhealth.models.BaseModel` -subclass implementing the Squeeze-Excitation ResNet (SE-ResNet-50) benchmarked in: - - Nonaka, N. & Seita, J. (2021). *In-depth Benchmarking of Deep Neural - Network Architectures for ECG Diagnosis.* Proceedings of Machine Learning - Research 126:1–19, MLHC 2021. - -From the paper (Appendix A.3): - "SE-ResNet is a ResNet with Squeeze-Excitation module (Hu et al., 2018). - Akin to ResNet and ResNeXt architecture, we implemented the same structure - to architecture used for image classification and replaced convolution and - batch normalization layer to 1d." - -Best hyperparameters from paper grid search (SE-ResNet-50, PTB-XL "all" task): - batch_size = 64, learning_rate = 0.01 → ROC-AUC = 0.9082 - -Architecture overview ---------------------- -The SE block (Hu et al., 2018) adds channel-wise recalibration to every -residual block: - -1. **Squeeze**: Global average pooling collapses spatial / temporal dimension - ``(B, C, T) → (B, C)``. -2. **Excitation**: Two-layer MLP with reduction ratio ``r=16`` learns - channel weights ``(B, C) → (B, C//r) → (B, C)``. -3. **Scale**: Element-wise multiply weights back to the feature map. - -The backbone follows ResNet-50 (layers = [3, 4, 6, 3]) with all 2D Conv / -BatchNorm replaced by 1D equivalents for ECG signals. - -:: - - Input (B, 12, T) (12 leads × T samples) - → Conv1d(12, 64, 7, s=2) → BN → ReLU → MaxPool1d(3, s=2) - → Layer 1 : 3 × Bottleneck1D(64, 64, 256) [no stride] - → Layer 2 : 4 × Bottleneck1D(256, 128, 512) [stride=2 on first] - → Layer 3 : 6 × Bottleneck1D(512, 256, 1024) [stride=2 on first] - → Layer 4 : 3 × Bottleneck1D(1024,512, 2048) [stride=2 on first] - → AdaptiveAvgPool1d(1) → Flatten → (B, 2048) - → neck : Linear(2048, backbone_out=256) [paper: all backbones output 256] - → head : Linear(256, 256) → ReLU → BN1d → Dropout(0.5) → Linear(256, K) - → BCEWithLogitsLoss (multi-label sigmoid per class) - -Bottleneck SE block structure -------------------------------- -Each Bottleneck1D block:: - - identity = x (or downsampled if stride > 1 / dim mismatch) - x → Conv1d(in, planes, 1) → BN → ReLU - → Conv1d(planes, planes, 3, padding=1) → BN → ReLU - → Conv1d(planes, planes*4, 1) → BN - → SEBlock1D(planes*4, r=se_reduction) ← channel recalibration - → + identity → ReLU - -Signal format expected ----------------------- -``feature_keys=["signal"]`` → each element is ``np.ndarray`` of shape -``(12, T)`` loaded from a ``.pkl`` file by ``SampleSignalDataset``. -T = 1000 at 100 Hz | T = 5000 at 500 Hz. - -PyHealth integration --------------------- -``SEResNetECG`` is a drop-in replacement for ``SparcNet`` and ``BiLSTMECG`` -in any PyHealth ``Trainer``-based pipeline:: - - model = SEResNetECG( - dataset = sample_dataset, - feature_keys = ["signal"], - label_key = "labels", - mode = "multilabel", - ) - trainer = Trainer(model=model, ...) - -Author: - CS-598 DLH Project Team — PyHealth contribution (April 2026) - -References: - - Nonaka & Seita (2021). In-depth Benchmarking of Deep Neural Network - Architectures for ECG Diagnosis. MLHC 2021. - - Hu et al. (2018). Squeeze-and-Excitation Networks. CVPR 2018. - - He et al. (2016). Deep Residual Learning for Image Recognition. CVPR 2016. -""" - -from typing import List, Optional - -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F - -from pyhealth.models import BaseModel - - -# ── Squeeze-and-Excitation module (Hu et al. 2018) ──────────────────────────── - -class SEBlock1D(nn.Module): - """Squeeze-and-Excitation block for 1D temporal signals. - - Performs channel recalibration via global pooling + two-layer MLP: - - 1. **Squeeze**: ``AdaptiveAvgPool1d(1) → (B, C)`` - 2. **Excitation**: ``Linear(C, C//r) → ReLU → Linear(C//r, C) → Sigmoid`` - 3. **Scale**: element-wise multiply back onto the input feature map. - - Args: - channels (int): Number of input/output channels ``C``. - reduction (int): Reduction ratio ``r`` for the MLP bottleneck. - Default ``16`` (as in the original SE-Net paper). - """ - - def __init__(self, channels: int, reduction: int = 16) -> None: - super().__init__() - mid = max(1, channels // reduction) - self.pool = nn.AdaptiveAvgPool1d(1) - self.fc1 = nn.Linear(channels, mid) - self.fc2 = nn.Linear(mid, channels) - self.relu = nn.ReLU(inplace=True) - self.sigmoid = nn.Sigmoid() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Args: - x: ``(B, C, T)`` feature map. - - Returns: - Channel-recalibrated feature map ``(B, C, T)``. - """ - b, c, _ = x.shape - # Squeeze: global average pool → (B, C) - z = self.pool(x).view(b, c) - # Excitation: MLP → channel weights in [0, 1] - z = self.relu(self.fc1(z)) - z = self.sigmoid(self.fc2(z)) - # Scale: broadcast back to (B, C, T) - return x * z.unsqueeze(-1) - - -# ── ResNet-50 Bottleneck block (1D, with SE) ─────────────────────────────────── - -class Bottleneck1D(nn.Module): - """ResNet-50 Bottleneck residual block adapted to 1D signals with SE. - - Bottleneck design (He et al., 2016): - Conv1d(in→planes, k=1) → BN → ReLU # reduce channels - Conv1d(planes→planes, k=3) → BN → ReLU # spatial mix - Conv1d(planes→planes*4, k=1) → BN # expand channels - SEBlock1D(planes*4) # channel recalibration (Hu 2018) - + identity (possibly downsampled) → ReLU - - Args: - in_channels (int): Input channel count. - planes (int): Bottleneck width (output = ``planes * expansion = planes * 4``). - stride (int): Stride for the 3×1 convolution. ``>1`` downsamples T. - downsample (nn.Module, optional): 1×1 conv to align identity when - ``in_channels != planes * 4`` or ``stride != 1``. - se_reduction (int): SE block reduction ratio. Default ``16``. - """ - - expansion: int = 4 - - def __init__( - self, - in_channels: int, - planes: int, - stride: int = 1, - downsample: Optional[nn.Module] = None, - se_reduction: int = 16, - ) -> None: - super().__init__() - out_channels = planes * self.expansion - - # 1×1 channel reduce - self.conv1 = nn.Conv1d(in_channels, planes, kernel_size=1, bias=False) - self.bn1 = nn.BatchNorm1d(planes) - # 3×1 temporal mix (stride here for downsampling) - self.conv2 = nn.Conv1d(planes, planes, kernel_size=3, - stride=stride, padding=1, bias=False) - self.bn2 = nn.BatchNorm1d(planes) - # 1×1 channel expand - self.conv3 = nn.Conv1d(planes, out_channels, kernel_size=1, bias=False) - self.bn3 = nn.BatchNorm1d(out_channels) - # Channel recalibration - self.se = SEBlock1D(out_channels, reduction=se_reduction) - # Residual shortcut - self.downsample = downsample - self.relu = nn.ReLU(inplace=True) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - identity = x - - out = self.relu(self.bn1(self.conv1(x))) - out = self.relu(self.bn2(self.conv2(out))) - out = self.bn3(self.conv3(out)) - out = self.se(out) # squeeze-and-excite - - if self.downsample is not None: - identity = self.downsample(x) - - return self.relu(out + identity) - - -# ── SEResNetECG — PyHealth BaseModel wrapper ─────────────────────────────────── - -class SEResNetECG(BaseModel): - """SE-ResNet-50 ECG classifier (Nonaka & Seita 2021, Appendix A.3). - - Backone: ResNet-50 (layers = [3, 4, 6, 3]) with all 2D Conv/BN replaced - by 1D equivalents and Squeeze-Excitation blocks after every Bottleneck. - A neck projects the 2048-dim pooled feature to ``backbone_out = 256`` - (matching the paper: "We set output size of all backbone module to 256"). - The prediction head (paper: FC → ReLU → BN → Dropout → FC) maps to ``K`` - output logits for multi-label classification. - - Args: - dataset: A PyHealth ``SampleSignalDataset`` (or ``Subset``) that - exposes ``input_info["signal"]["n_channels"]``. - feature_keys (List[str]): Must be ``["signal"]``. - label_key (str): Sample key holding the label list (``"labels"`` for - the jtwells2 / PTBXLMultilabelClassification schema). - mode (str): ``"multilabel"`` applies ``BCEWithLogitsLoss``. - layers (List[int]): Block counts per stage. Default ``[3, 4, 6, 3]`` - (ResNet-50). Use ``[2, 2, 2, 2]`` for a lighter SE-ResNet-18. - se_reduction (int): SE block reduction ratio. Paper uses ``16``. - backbone_out (int): Dimension of the neck projection. Paper uses - ``256`` for all backbone architectures. - dropout (float): Dropout probability in the prediction head. ``0.5`` - matches the paper's training setting. - - Examples: - Paper-aligned SE-ResNet-50:: - - >>> from se_resnet_ecg import SEResNetECG - >>> model = SEResNetECG( - ... dataset = sample_dataset, - ... feature_keys = ["signal"], - ... label_key = "labels", - ... mode = "multilabel", - ... ) - - Lighter SE-ResNet-18 variant:: - - >>> model = SEResNetECG( - ... dataset = sample_dataset, - ... feature_keys = ["signal"], - ... label_key = "labels", - ... mode = "multilabel", - ... layers = [2, 2, 2, 2], - ... ) - """ - - def __init__( - self, - dataset, - feature_keys: List[str], - label_key: str, - mode: str, - layers: List[int] = None, - se_reduction: int = 16, - backbone_out: int = 256, - dropout: float = 0.5, - **kwargs, - ) -> None: - super().__init__( - dataset = dataset, - feature_keys = feature_keys, - label_key = label_key, - mode = mode, - ) - - if layers is None: - layers = [3, 4, 6, 3] # ResNet-50 default - - sig_info = self.dataset.input_info["signal"] - in_channels = sig_info["n_channels"] # 12 leads - - self.label_tokenizer = self.get_label_tokenizer() - output_size = self.get_output_size(self.label_tokenizer) - - # ── Stem (ResNet conv1) ──────────────────────────────────────────── - self._in_channels = 64 - self.conv1 = nn.Conv1d(in_channels, 64, kernel_size=7, - stride=2, padding=3, bias=False) - self.bn1 = nn.BatchNorm1d(64) - self.relu = nn.ReLU(inplace=True) - self.maxpool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) - - # ── Residual stages ──────────────────────────────────────────────── - self.layer1 = self._make_layer(64, layers[0], se_reduction=se_reduction) - self.layer2 = self._make_layer(128, layers[1], stride=2, se_reduction=se_reduction) - self.layer3 = self._make_layer(256, layers[2], stride=2, se_reduction=se_reduction) - self.layer4 = self._make_layer(512, layers[3], stride=2, se_reduction=se_reduction) - - # ── Neck: project 2048 → backbone_out (256 per paper) ───────────── - self.avgpool = nn.AdaptiveAvgPool1d(1) - self.neck = nn.Linear(512 * Bottleneck1D.expansion, backbone_out) - - # ── Prediction head (paper: FC → ReLU → BN → Dropout → FC) ──────── - self.head = nn.Sequential( - nn.Linear(backbone_out, backbone_out), - nn.ReLU(inplace=True), - nn.BatchNorm1d(backbone_out), - nn.Dropout(p=dropout), - nn.Linear(backbone_out, output_size), - ) - - # Weight initialisation (Kaiming uniform for conv, constant for BN) - self._init_weights() - - # ── Internal helpers ─────────────────────────────────────────────────────── - - def _make_layer( - self, - planes: int, - num_blocks: int, - stride: int = 1, - se_reduction: int = 16, - ) -> nn.Sequential: - """Build one ResNet stage with ``num_blocks`` Bottleneck1D blocks.""" - downsample = None - out_channels = planes * Bottleneck1D.expansion - if stride != 1 or self._in_channels != out_channels: - downsample = nn.Sequential( - nn.Conv1d(self._in_channels, out_channels, - kernel_size=1, stride=stride, bias=False), - nn.BatchNorm1d(out_channels), - ) - - layers_list = [ - Bottleneck1D(self._in_channels, planes, stride, downsample, se_reduction) - ] - self._in_channels = out_channels - for _ in range(1, num_blocks): - layers_list.append( - Bottleneck1D(self._in_channels, planes, - se_reduction=se_reduction) - ) - return nn.Sequential(*layers_list) - - def _init_weights(self) -> None: - """Kaiming normal init for Conv1d; constant init for BatchNorm.""" - for m in self.modules(): - if isinstance(m, nn.Conv1d): - nn.init.kaiming_normal_(m.weight, mode="fan_out", - nonlinearity="relu") - elif isinstance(m, nn.BatchNorm1d): - nn.init.constant_(m.weight, 1) - nn.init.constant_(m.bias, 0) - - # ── Forward pass ────────────────────────────────────────────────────────── - - def forward(self, **kwargs) -> dict: - """Run inference and compute loss. - - Keyword arguments are the batch dict produced by PyHealth's - ``collate_fn_dict`` (keys: ``"signal"``, ``"labels"``, etc.). - - Returns: - dict with keys: - - ``"loss"`` – scalar ``BCEWithLogitsLoss`` - - ``"y_prob"`` – sigmoid probabilities ``(B, K)`` - - ``"y_true"`` – multi-hot ground truth ``(B, K)`` - - ``"logit"`` – raw logits ``(B, K)`` - """ - # Load signal: List[np.ndarray(12, T)] → Tensor(B, 12, T) - x = torch.tensor( - np.array(kwargs[self.feature_keys[0]]), - device=self.device, - ).float() - - # ── Stem ──────────────────────────────────────────────────────────── - x = self.maxpool(self.relu(self.bn1(self.conv1(x)))) # (B, 64, T//4) - - # ── Residual stages ───────────────────────────────────────────────── - x = self.layer1(x) # (B, 256, T//4) - x = self.layer2(x) # (B, 512, T//8) - x = self.layer3(x) # (B, 1024, T//16) - x = self.layer4(x) # (B, 2048, T//32) - - # ── Pooling + neck ────────────────────────────────────────────────── - x = self.avgpool(x).squeeze(-1) # (B, 2048) - x = self.neck(x) # (B, 256) - - # ── Prediction head ───────────────────────────────────────────────── - logits = self.head(x) # (B, K) - - # ── Loss and probabilities (handled by BaseModel) ─────────────────── - y_true = self.prepare_labels(kwargs[self.label_key], self.label_tokenizer) - loss = self.get_loss_function()(logits, y_true) - y_prob = self.prepare_y_prob(logits) - - return {"loss": loss, "y_prob": y_prob, "y_true": y_true, "logit": logits}