deepecgkit 0.1.0__py3-none-any.whl

deepecgkit/registry.py

@@ -0,0 +1,97 @@
+"""
+Model and dataset registry for deepecg-kit.
+
+Provides decorator-based registration so new models and datasets are
+automatically discoverable by the CLI and other consumers.
+
+Usage:
+    from deepecgkit.registry import register_model, register_dataset
+
+    @register_model("my-model", description="My custom model")
+    class MyModel(nn.Module):
+        ...
+
+    @register_dataset("my-dataset", input_channels=1, description="My dataset")
+    class MyDataset(BaseECGDataset):
+        ...
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Type
+
+_MODEL_REGISTRY: Dict[str, Dict[str, Any]] = {}
+_DATASET_REGISTRY: Dict[str, Dict[str, Any]] = {}
+
+
+def register_model(
+    name: str,
+    description: str = "",
+    default_kwargs: Optional[Dict[str, Any]] = None,
+) -> Callable:
+    def decorator(cls: Type) -> Type:
+        _MODEL_REGISTRY[name] = {
+            "class": cls,
+            "description": description,
+            "default_kwargs": default_kwargs or {},
+        }
+        cls._registry_name = name
+        return cls
+
+    return decorator
+
+
+def register_dataset(
+    name: str,
+    input_channels: int,
+    num_classes: Optional[int] = None,
+    description: str = "",
+) -> Callable:
+    def decorator(cls: Type) -> Type:
+        _DATASET_REGISTRY[name] = {
+            "class": cls,
+            "input_channels": input_channels,
+            "num_classes": num_classes,
+            "description": description,
+        }
+        cls._registry_name = name
+        return cls
+
+    return decorator
+
+
+def get_model(name: str) -> Type:
+    if name not in _MODEL_REGISTRY:
+        available = ", ".join(sorted(_MODEL_REGISTRY.keys()))
+        raise KeyError(f"Unknown model: {name}. Available: {available}")
+    return _MODEL_REGISTRY[name]["class"]
+
+
+def get_dataset(name: str) -> Type:
+    if name not in _DATASET_REGISTRY:
+        available = ", ".join(sorted(_DATASET_REGISTRY.keys()))
+        raise KeyError(f"Unknown dataset: {name}. Available: {available}")
+    return _DATASET_REGISTRY[name]["class"]
+
+
+def get_model_names() -> List[str]:
+    return sorted(_MODEL_REGISTRY.keys())
+
+
+def get_dataset_names() -> List[str]:
+    return sorted(_DATASET_REGISTRY.keys())
+
+
+def get_model_info(name: str) -> Dict[str, Any]:
+    if name not in _MODEL_REGISTRY:
+        raise KeyError(f"Unknown model: {name}")
+    return dict(_MODEL_REGISTRY[name])
+
+
+def get_dataset_info(name: str) -> Dict[str, Any]:
+    if name not in _DATASET_REGISTRY:
+        raise KeyError(f"Unknown dataset: {name}")
+    entry = dict(_DATASET_REGISTRY[name])
+    if entry["num_classes"] is None:
+        cls = entry["class"]
+        if hasattr(cls, "CLASS_LABELS"):
+            entry["num_classes"] = len(cls.CLASS_LABELS)
+    return entry

deepecgkit/training/__init__.py

@@ -0,0 +1,9 @@
+"""
+Training modules for ECG models.
+
+This module provides training utilities and Lightning modules for ECG model training.
+"""
+
+from deepecgkit.training.train import ECGLitModel
+
+__all__ = ["ECGLitModel"]

deepecgkit/training/train.py

@@ -0,0 +1,171 @@
+import pytorch_lightning as pl
+import torch
+
+
+class ECGLitModel(pl.LightningModule):
+    """
+    PyTorch Lightning module for ECG signal classification and regression.
+
+    This module wraps ECG models and provides training, validation, and testing
+    functionality with configurable optimizers and learning rate schedulers.
+
+    Args:
+        model: The ECG model to train (e.g., KanResWideX, AFModel)
+        train_config: Dictionary containing training configuration:
+            - learning_rate: Learning rate for optimizer
+            - scheduler: Dict with 'factor' and 'patience' for ReduceLROnPlateau
+            - binary_classification: Bool, if True uses BCE loss for binary tasks
+            - multi_label: Bool, if True uses BCE loss for multi-label tasks
+        use_plateau_scheduler: If True, uses ReduceLROnPlateau, else StepLR
+
+    Example:
+        >>> model = KanResWideX(input_channels=1, output_size=4)
+        >>> config = {
+        ...     "learning_rate": 0.001,
+        ...     "scheduler": {"factor": 0.5, "patience": 10},
+        ...     "binary_classification": False
+        ... }
+        >>> lit_model = ECGLitModel(model=model, train_config=config)
+    """
+
+    def __init__(self, model, train_config, use_plateau_scheduler=True):
+        super().__init__()
+        self.save_hyperparameters(ignore=["model"])
+
+        self.model = model
+
+        self.learning_rate = train_config["learning_rate"]
+        self.scheduler_factor = train_config["scheduler"]["factor"]
+        self.scheduler_patience = train_config["scheduler"]["patience"]
+
+        self.use_plateau_scheduler = use_plateau_scheduler
+        self.multi_label = train_config.get("multi_label", False)
+
+        if self.multi_label or train_config.get("binary_classification", False):
+            pos_weight = train_config.get("pos_weight")
+            if pos_weight is not None:
+                pos_weight = torch.tensor(pos_weight, dtype=torch.float32)
+            self.criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
+        elif train_config.get("task_type", "classification") == "classification":
+            self.criterion = torch.nn.CrossEntropyLoss()
+        else:
+            self.criterion = torch.nn.MSELoss()
+
+        self.test_predictions = []
+        self.test_targets = []
+        self.test_probabilities = []
+
+    @property
+    def _is_binary(self):
+        return isinstance(self.criterion, torch.nn.BCEWithLogitsLoss) and not self.multi_label
+
+    @property
+    def _is_classification(self):
+        return isinstance(self.criterion, (torch.nn.CrossEntropyLoss, torch.nn.BCEWithLogitsLoss))
+
+    def _calculate_loss(self, y_hat, y):
+        if self.multi_label:
+            return self.criterion(y_hat, y.float())
+        if self._is_binary:
+            return self.criterion(y_hat.squeeze(-1), y.float())
+        if isinstance(self.criterion, torch.nn.CrossEntropyLoss):
+            return self.criterion(y_hat, y.long())
+        return self.criterion(y_hat.float(), y.float())
+
+    def _compute_acc(self, y_hat, y):
+        if self.multi_label:
+            preds = (y_hat > 0).float()
+            return (preds == y.float()).float().mean()
+        if self._is_binary:
+            preds = (y_hat.squeeze(-1) > 0).long()
+            return (preds == y.long()).float().mean()
+        return (torch.argmax(y_hat, dim=1) == y.long()).float().mean()
+
+    def forward(self, x):
+        return self.model(x)
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+        loss = self._calculate_loss(y_hat, y)
+        if hasattr(self.model, "l2_regularization_loss"):
+            l2_loss = self.model.l2_regularization_loss()
+            loss = loss + l2_loss
+        self.log("train_loss", loss, prog_bar=True)
+        if self._is_classification:
+            self.log("train_acc", self._compute_acc(y_hat, y), prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+        loss = self._calculate_loss(y_hat, y)
+        self.log("val_loss", loss, prog_bar=True)
+        if self._is_classification:
+            self.log("val_acc", self._compute_acc(y_hat, y), prog_bar=True)
+        return loss
+
+    def on_test_epoch_start(self):
+        self.test_predictions = []
+        self.test_targets = []
+        self.test_probabilities = []
+
+    def test_step(self, batch, batch_idx):
+        x, y = batch
+        y_hat = self(x)
+        loss = self._calculate_loss(y_hat, y)
+        self.log("test_loss", loss, prog_bar=True)
+        if self._is_classification:
+            if self.multi_label:
+                probs = torch.sigmoid(y_hat)
+                preds = (probs > 0.5).long()
+                acc = (preds == y.long()).float().mean()
+                self.test_predictions.append(preds.cpu())
+                self.test_targets.append(y.long().cpu())
+                self.test_probabilities.append(probs.cpu())
+            elif self._is_binary:
+                probs_pos = torch.sigmoid(y_hat.squeeze(-1))
+                probs = torch.stack([1 - probs_pos, probs_pos], dim=1)
+                preds = (probs_pos > 0.5).long()
+                acc = (preds == y.long()).float().mean()
+                self.test_predictions.append(preds.cpu())
+                self.test_targets.append(y.long().cpu())
+                self.test_probabilities.append(probs.cpu())
+            else:
+                probs = torch.softmax(y_hat, dim=1)
+                preds = torch.argmax(probs, dim=1)
+                acc = (preds == y.long()).float().mean()
+                self.test_predictions.append(preds.cpu())
+                self.test_targets.append(y.long().cpu())
+                self.test_probabilities.append(probs.cpu())
+            self.log("test_acc", acc, prog_bar=True)
+        return loss
+
+    def get_test_results(self):
+        if not self.test_predictions:
+            return None, None, None
+        return (
+            torch.cat(self.test_predictions).numpy(),
+            torch.cat(self.test_targets).numpy(),
+            torch.cat(self.test_probabilities).numpy(),
+        )
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)
+        if self.use_plateau_scheduler:
+            scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+                optimizer,
+                mode="min",
+                factor=self.scheduler_factor,
+                patience=self.scheduler_patience,
+            )
+            return {
+                "optimizer": optimizer,
+                "lr_scheduler": {"scheduler": scheduler, "monitor": "val_loss"},
+            }
+        else:
+            scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)
+            return {
+                "optimizer": optimizer,
+                "lr_scheduler": scheduler,
+            }

deepecgkit/utils/__init__.py

@@ -0,0 +1,72 @@
+import csv
+import os
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+
+from deepecgkit.utils.weights import (
+    list_pretrained_weights,
+    load_pretrained_weights,
+    register_weights,
+)
+
+__all__ = [
+    "list_pretrained_weights",
+    "load_pretrained_weights",
+    "read_csv",
+    "register_weights",
+]
+
+
+def read_csv(
+    csv_file: str,
+    delimiter: str = ",",
+    transpose: bool = False,
+    skip_header: bool = True,
+    dtype: Optional[type] = None,
+) -> Tuple[np.ndarray, Dict[str, int]]:
+    """
+    Read CSV file and return data array and header mapping.
+
+    Args:
+        csv_file: Path to the CSV file
+        delimiter: Column delimiter (default: ',')
+        transpose: Whether to transpose the data array
+        skip_header: Whether to skip the first row as header
+        dtype: Data type for the numpy array
+
+    Returns:
+        Tuple of (data_array, header_mapping)
+    """
+    if not os.path.exists(csv_file):
+        raise FileNotFoundError(f"CSV file not found: {csv_file}")
+
+    data: List[List[str]] = []
+    header: Dict[str, int] = {}
+
+    try:
+        with open(csv_file) as f:
+            csv_data = csv.reader(f, delimiter=delimiter)
+
+            if skip_header:
+                try:
+                    temp = next(csv_data)
+                    header = {k: v for v, k in enumerate(temp)}
+                except StopIteration as err:
+                    raise ValueError("File is empty") from err
+
+            for row in csv_data:
+                data.append(row)
+
+        if not data:
+            raise ValueError("No data found in CSV file")
+
+        data_array = np.array(data, dtype=dtype)
+
+        if transpose:
+            data_array = np.transpose(data_array)
+
+        return data_array, header
+
+    except Exception as err:
+        raise ValueError(f"Error reading CSV file: {err!s}") from err

deepecgkit/utils/download.py

@@ -0,0 +1,123 @@
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import List, Optional, Union
+
+from tqdm import tqdm
+
+
+class DownloadProgressBar(tqdm):
+    """Progress bar for downloads."""
+
+    def update_to(self, b=1, bsize=1, tsize=None):
+        if tsize is not None:
+            self.total = tsize
+        self.update(b * bsize - self.n)
+
+
+def download_file(
+    url: str,
+    file_path: Union[str, Path],
+    desc: Optional[str] = None,
+    force: bool = False,
+    max_retries: int = 3,
+) -> None:
+    """Download a file with a progress bar.
+
+    Args:
+        url: URL to download from
+        file_path: Path to save the file to
+        desc: Description for the progress bar
+        force: If True, re-download even if file exists
+        max_retries: Maximum number of download attempts
+    """
+    file_path = Path(file_path)
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if file_path.exists() and not force:
+        if file_path.suffix.lower() == ".zip":
+            try:
+                with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    if zip_ref.testzip() is not None:
+                        print(f"Corrupted zip file detected at {file_path}, re-downloading...")
+                        file_path.unlink()
+                    else:
+                        print(f"File already exists at {file_path}, skipping download.")
+                        return
+            except zipfile.BadZipFile:
+                print(f"Corrupted zip file detected at {file_path}, re-downloading...")
+                file_path.unlink()
+        else:
+            print(f"File already exists at {file_path}, skipping download.")
+            return
+
+    last_exception = None
+    for attempt in range(max_retries):
+        try:
+            with DownloadProgressBar(unit="B", unit_scale=True, miniters=1, desc=desc) as t:
+                urllib.request.urlretrieve(url, filename=file_path, reporthook=t.update_to)
+
+            if file_path.suffix.lower() == ".zip":
+                with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    if zip_ref.testzip() is not None:
+                        raise zipfile.BadZipFile("Downloaded zip file is corrupted")
+            return
+
+        except Exception as e:
+            last_exception = e
+            if file_path.exists():
+                file_path.unlink()
+
+            if attempt < max_retries - 1:
+                wait_time = 2**attempt
+                print(f"Download attempt {attempt + 1} failed: {e}")
+                print(f"Retrying in {wait_time} seconds...")
+                time.sleep(wait_time)
+            else:
+                raise RuntimeError(
+                    f"Failed to download {url} after {max_retries} attempts: {last_exception}"
+                ) from last_exception
+
+
+def download_and_extract(
+    urls: List[str],
+    file_paths: List[Union[str, Path]],
+    extract_dir: Optional[Union[str, Path]] = None,
+    descs: Optional[List[str]] = None,
+    force: bool = False,
+) -> None:
+    """Download files and optionally extract zip files.
+
+    Args:
+        urls: List of URLs to download from
+        file_paths: List of paths to save the files to
+        extract_dir: Directory to extract zip files to. If None, files are not extracted
+        descs: List of descriptions for the progress bars
+        force: If True, re-download even if files exist
+    """
+    if descs is None:
+        descs = [f"Downloading file {i + 1}/{len(urls)}" for i in range(len(urls))]
+
+    for url, file_path_str, desc in zip(urls, file_paths, descs):
+        file_path = Path(file_path_str)
+        download_file(url, file_path, desc, force=force, max_retries=3)
+
+        if extract_dir is not None and file_path.suffix.lower() == ".zip":
+            extract_dir = Path(extract_dir)
+            extracted_marker = extract_dir / f".{file_path.stem}_extracted"
+
+            if extracted_marker.exists() and not force:
+                print(f"{file_path.name} already extracted, skipping...")
+                continue
+
+            print(f"Extracting {file_path.name} to {extract_dir}...")
+            try:
+                with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    zip_ref.extractall(extract_dir)
+                extracted_marker.touch()
+                file_path.unlink()
+            except Exception as e:
+                if extracted_marker.exists():
+                    extracted_marker.unlink()
+                raise RuntimeError(f"Failed to extract {file_path}: {e}") from e

deepecgkit/utils/weights.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+import torch
+
+from deepecgkit.utils.download import download_file
+
+WEIGHTS_REGISTRY: Dict[str, Dict] = {
+    "kanres-af-30s": {
+        "url": "https://github.com/your-org/deepecg-kit/releases/download/v1.0.0/kanres-af-30s.pt",
+        "model_class": "KanResWideX",
+        "model_kwargs": {"input_channels": 1, "output_size": 4, "base_channels": 64},
+        "description": "KanResWideX trained on AF classification (30s recordings)",
+    },
+    "afmodel-30s": {
+        "url": "https://github.com/your-org/deepecg-kit/releases/download/v1.0.0/afmodel-30s.pt",
+        "model_class": "AFModel",
+        "model_kwargs": {"recording_length": 30},
+        "description": "AFModel trained on PhysioNet 2017 Challenge (30s recordings)",
+    },
+}
+
+
+def get_weights_dir() -> Path:
+    cache_dir = Path.home() / ".cache" / "deepecgkit" / "weights"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def list_pretrained_weights() -> Dict[str, str]:
+    """List all available pretrained weights with descriptions."""
+    return {name: info["description"] for name, info in WEIGHTS_REGISTRY.items()}
+
+
+def get_weight_info(weight_name: str) -> Dict:
+    """Get information about a specific pretrained weight."""
+    if weight_name not in WEIGHTS_REGISTRY:
+        available = ", ".join(WEIGHTS_REGISTRY.keys())
+        raise ValueError(f"Unknown weight '{weight_name}'. Available: {available}")
+    return WEIGHTS_REGISTRY[weight_name]
+
+
+def download_weights(weight_name: str, force: bool = False) -> Path:
+    """Download pretrained weights by name.
+
+    Args:
+        weight_name: Name of the pretrained weights (e.g., "kanres-af-30s")
+        force: If True, re-download even if weights exist locally
+
+    Returns:
+        Path to the downloaded weights file
+    """
+    info = get_weight_info(weight_name)
+    weights_dir = get_weights_dir()
+    weight_path = weights_dir / f"{weight_name}.pt"
+
+    download_file(
+        url=info["url"],
+        file_path=weight_path,
+        desc=f"Downloading {weight_name} weights",
+        force=force,
+    )
+
+    return weight_path
+
+
+def load_pretrained_weights(
+    weight_name: str,
+    map_location: Optional[Union[str, torch.device]] = None,
+    force_download: bool = False,
+) -> Dict:
+    """Load pretrained weights by name.
+
+    Args:
+        weight_name: Name of the pretrained weights
+        map_location: Device to map weights to (e.g., "cpu", "cuda")
+        force_download: If True, re-download weights even if cached
+
+    Returns:
+        State dict containing model weights
+    """
+    weight_path = download_weights(weight_name, force=force_download)
+    return torch.load(weight_path, map_location=map_location, weights_only=True)
+
+
+def register_weights(
+    name: str,
+    url: str,
+    model_class: str,
+    model_kwargs: Dict,
+    description: str = "",
+) -> None:
+    """Register custom pretrained weights.
+
+    Args:
+        name: Unique name for the weights
+        url: URL to download weights from
+        model_class: Name of the model class these weights are for
+        model_kwargs: Keyword arguments to instantiate the model
+        description: Human-readable description of the weights
+    """
+    WEIGHTS_REGISTRY[name] = {
+        "url": url,
+        "model_class": model_class,
+        "model_kwargs": model_kwargs,
+        "description": description,
+    }

deepecgkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: deepecgkit
+Version: 0.1.0
+Summary: A deep learning toolkit for ECG analysis
+Author-email: Steven <steven@simula.no>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: torch>=1.9.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=0.24.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: wfdb>=3.4.0
+Requires-Dist: pyEDFlib>=0.1.0
+Requires-Dist: PyWavelets>=1.1.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: pytorch-lightning>=1.5.0
+Requires-Dist: litmodels>=0.1.8
+Requires-Dist: tensorboardx>=2.6.2.2
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.900; extra == "dev"
+Requires-Dist: ruff>=0.11.13; extra == "dev"
+Dynamic: license-file
+
+# DeepECG-Kit
+
+A PyTorch Lightning-based deep learning library for ECG analysis and arrhythmia classification. Provides a CLI for training, evaluation, and inference across multiple model architectures and ECG datasets.
+
+Install with `pip install deepecgkit`, or for local development clone the repo and run `pip install -e ".[dev]"`.
+
+## Usage
+
+```bash
+deepecg train -m kanres -d af-classification    # train (auto-downloads dataset)
+deepecg evaluate --checkpoint model.ckpt -d af-classification
+deepecg predict --checkpoint model.ckpt --input ecg.npy
+deepecg resume --checkpoint model.ckpt --epochs 100
+deepecg list-models                              # list available models/datasets
+deepecg list-datasets
+deepecg info -m kanres
+```
+
+**Models:** `afmodel`, `convnext-v2`, `crnn`, `deep-res-cnn`, `dualnet`, `fcn-wang`, `gru`, `inception-time`, `kanres`, `kanres-deep`, `lstm`, `mamba`, `medformer`, `resnet`, `resnet-wang`, `se-resnet`, `simple-cnn`, `tcn`, `transformer`, `xresnet`, `xresnet1d-benchmark`
+
+**Datasets:** `af-classification` (1-lead, 4-class, PhysioNet 2017), `ptbxl` (12-lead, 5 superclasses, multi-label), `mitbih-afdb` (2-lead, binary/4-class, MIT-BIH AFDB), `ltafdb` (2-lead, binary/4-class, Long-Term AFDB), `unified-af` (1-lead, 4-class, combined cross-dataset).
+
+## Experiments
+
+Experiments are defined in `experiments.yaml` and run via `python scripts/run_experiments.py`. Each experiment trains a model on a dataset using the CLI under the hood. Results save to `runs/{timestamp}-{model}-{dataset}/` with checkpoints (top 3 by val_loss), training plots, and test evaluation (confusion matrix, classification report).
+
+### Default Training Parameters
+
+| Parameter | Value |
+|-----------|-------|
+| Epochs | 50 |
+| Batch size | 32 |
+| Learning rate | 0.001 |
+| Optimizer | Adam |
+| LR scheduler | ReduceLROnPlateau (factor=0.5, patience=5) |
+| Early stopping patience | 10 |
+| Validation split | 0.2 |
+| Test split | 0.1 |
+| Seed | 42 |
+
+## References
+
+### Datasets
+
+1. **af-classification** — Clifford GD, Liu C, Moody B, Li-wei HL, Silva I, Li Q, Johnson AE, Mark RG. "AF Classification from a Short Single Lead ECG Recording: The PhysioNet/Computing in Cardiology Challenge 2017." *Computing in Cardiology (CinC)*, 2017. [[PhysioNet]](https://physionet.org/content/challenge-2017/1.0.0/)
+
+2. **ptbxl** — Wagner P, Strodthoff N, Bousseljot RD, Kreiseler D, Lunze FI, Samek W, Schaeffter T. "PTB-XL, a Large Publicly Available Electrocardiography Dataset." *Scientific Data*, 7(1):154, 2020. [[PhysioNet]](https://physionet.org/content/ptb-xl/1.0.3/)
+
+3. **mitbih-afdb** — Moody GB, Mark RG. "A New Method for Detecting Atrial Fibrillation Using R-R Intervals." *Computers in Cardiology*, 10:227–230, 1983. [[PhysioNet]](https://physionet.org/content/afdb/1.0.0/)
+
+4. **ltafdb** — Petrutiu S, Sahakian AV, Swiryn S. "Abrupt Changes in Fibrillatory Wave Characteristics at the Termination of Paroxysmal Atrial Fibrillation in Humans." *Europace*, 9(7):466–470, 2007. [[PhysioNet]](https://physionet.org/content/ltafdb/1.0.0/)
+
+5. **unified-af** — Combined cross-dataset using af-classification, mitbih-afdb, and ltafdb (see references above).
+
+### Models
+
+6. **convnext-v2** — Woo S, Debnath S, Hu R, Chen X, Liu Z, Kweon IS, Xie S. "ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders." *CVPR*, 2023. [[GitHub]](https://github.com/facebookresearch/ConvNeXt-V2)
+
+7. **deep-res-cnn** — Elyamani H. "ECG Classification Using Deep Residual CNN." 2022. [[GitHub]](https://github.com/HaneenElyamani/ECG-classification)
+
+8. **inception-time** — Fawaz HI, Lucas B, Forestier G, Pelletier C, Schmidt DF, Weber J, Webb GI, Idoumghar L, Muller PA, Petitjean F. "InceptionTime: Finding AlexNet for Time Series Classification." *Data Mining and Knowledge Discovery*, 34:1936–1962, 2020. [[GitHub]](https://github.com/hfawaz/InceptionTime)
+
+9.  **mamba** — Gu A, Dao T. "Mamba: Linear-Time Sequence Modeling with Selective State Spaces." *arXiv:2312.00752*, 2023. [[GitHub]](https://github.com/state-spaces/mamba)
+
+10. **medformer** — Wang N, Liang X, Wang Z, Zhao J, Liu Y, Peng L, Miao C. "MedFormer: A Multi-Granularity Patching Transformer for Medical Time-Series Classification." *NeurIPS*, 2024. [[GitHub]](https://github.com/DL4mHealth/Medformer)
+
+11. **xresnet / xresnet1d-benchmark** — Strodthoff N, Wagner P, Schaeffter T, Samek W. "Deep Learning for ECG Analysis: Benchmarks and Insights from PTB-XL." *IEEE Journal of Biomedical and Health Informatics*, 25(5):1519–1528, 2021. [[GitHub]](https://github.com/helme/ecg_ptbxl_benchmarking)