deepecgkit 0.1.0__tar.gz → 0.2.0__tar.gz

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepecgkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: A deep learning toolkit for ECG analysis
 Author-email: Steven <steven@simula.no>
 Classifier: Programming Language :: Python :: 3
@@ -19,20 +19,24 @@ 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
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: pyyaml>=6.0.3
 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"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.25.0; extra == "docs"
+Requires-Dist: mkdocs-autorefs>=1.0.0; extra == "docs"
 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.
+A pure-PyTorch 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]"`.
 

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/README.md

@@ -1,6 +1,6 @@
 # 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.
+A pure-PyTorch 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]"`.
 

deepecgkit-0.2.0/deepecgkit/__init__.py

@@ -0,0 +1,17 @@
+"""DeepECG-Kit: Deep learning library for ECG analysis and arrhythmia classification."""
+
+from deepecgkit.datasets import ECGDataModule
+from deepecgkit.models import KanResWideX
+from deepecgkit.training import ECGTrainer
+from deepecgkit.utils import read_csv
+
+__version__ = "0.1.0"
+__author__ = "DeepECG Kit Contributors"
+__license__ = "MIT"
+
+__all__ = [
+    "ECGDataModule",
+    "ECGTrainer",
+    "KanResWideX",
+    "read_csv",
+]

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/cli/__init__.py

@@ -36,7 +36,7 @@ from deepecgkit.cli.registry import (
     _get_dataset_registry,
     _get_model_registry,
 )
-from deepecgkit.training import ECGLitModel
+from deepecgkit.training import ECGTrainer
 
 __all__ = [
     "DATASET_INPUT_CHANNELS",
@@ -46,7 +46,7 @@ __all__ = [
     "MODEL_NAMES",
     "MODEL_WEIGHTS",
     "CLILogger",
-    "ECGLitModel",
+    "ECGTrainer",
     "_get_dataset_registry",
     "_get_model_registry",
     "evaluate",

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/cli/commands/evaluate.py

@@ -3,17 +3,21 @@
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-import pytorch_lightning as pl
-
 from deepecgkit.cli.logger import CLILogger
-from deepecgkit.cli.registry import DATASET_NAMES, _get_dataset_registry
+from deepecgkit.cli.registry import (
+    DATASET_NAMES,
+    MODEL_NAMES,
+    _get_dataset_registry,
+    _get_model_registry,
+)
 from deepecgkit.datasets import ECGDataModule
-from deepecgkit.training import ECGLitModel
+from deepecgkit.training import ECGTrainer
 
 
 def evaluate(
     checkpoint: str,
     dataset_name: str,
+    model_name: str,
     data_dir: Optional[str] = None,
     batch_size: int = 32,
     num_workers: int = 4,
@@ -32,15 +36,23 @@ def evaluate(
         return 1
 
     dataset_registry = _get_dataset_registry()
+    model_registry = _get_model_registry()
 
     if dataset_name not in dataset_registry:
         logger.error(f"Unknown dataset: {dataset_name}")
         logger.info(f"Available datasets: {', '.join(DATASET_NAMES)}")
         return 1
 
+    if model_name not in model_registry:
+        logger.error(f"Unknown model: {model_name}")
+        logger.info(f"Available models: {', '.join(MODEL_NAMES)}")
+        return 1
+
     try:
         logger.info(f"Loading model from {checkpoint}...")
-        lit_model = ECGLitModel.load_from_checkpoint(checkpoint)
+        model_class = model_registry[model_name]
+        model = model_class(input_channels=1, output_size=4)
+        trainer = ECGTrainer.load_checkpoint(checkpoint, model=model, device=accelerator)
 
         dataset_class = dataset_registry[dataset_name]
         dataset_kwargs: Dict[str, Any] = {"force_download": force_download}
@@ -56,17 +68,11 @@ def evaluate(
             dataset_kwargs=dataset_kwargs,
         )
 
-        trainer = pl.Trainer(
-            accelerator=accelerator,
-            devices=devices,
-            enable_progress_bar=not logger.quiet,
-        )
-
         logger.info(f"Running evaluation on {split} split...")
         if split == "test":
-            results = trainer.test(lit_model, data_module)
+            results = trainer.test(data_module)
         elif split == "val":
-            results = trainer.validate(lit_model, data_module)
+            results = trainer.validate(data_module)
         else:
             logger.error(f"Invalid split: {split}. Use 'test' or 'val'.")
             return 1
@@ -74,7 +80,7 @@ def evaluate(
         if results:
             logger.info("\nEvaluation Results:")
             logger.info("-" * 40)
-            for key, value in results[0].items():
+            for key, value in results.items():
                 logger.info(f"  {key}: {value:.4f}")
 
         return 0

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/cli/commands/predict.py

@@ -9,8 +9,8 @@ import pandas as pd
 import torch
 import wfdb
 
-import deepecgkit.cli as _cli
 from deepecgkit.cli.logger import CLILogger
+from deepecgkit.cli.registry import _get_model_registry
 
 
 def predict(
@@ -19,6 +19,7 @@ def predict(
     output_path: Optional[str] = None,
     batch_size: int = 1,
     accelerator: str = "auto",
+    model_name: Optional[str] = None,
     logger: Optional[CLILogger] = None,
 ) -> int:
     """Run inference on ECG data."""
@@ -36,8 +37,21 @@ def predict(
 
     try:
         logger.info(f"Loading model from {checkpoint}...")
-        lit_model = _cli.ECGLitModel.load_from_checkpoint(checkpoint)
-        lit_model.eval()
+        ckpt = torch.load(checkpoint, map_location="cpu", weights_only=False)
+
+        if model_name is None:
+            logger.error("--model is required for predict command")
+            return 1
+
+        model_registry = _get_model_registry()
+        if model_name not in model_registry:
+            logger.error(f"Unknown model: {model_name}")
+            return 1
+
+        model_class = model_registry[model_name]
+        model = model_class(input_channels=1, output_size=4)
+        model.load_state_dict(ckpt["model_state_dict"])
+        model.eval()
 
         logger.info(f"Loading input data from {input_path}...")
         if input_file.suffix == ".npy":
@@ -61,11 +75,11 @@ def predict(
 
         logger.info("Running inference...")
         device = "cuda" if accelerator == "gpu" and torch.cuda.is_available() else "cpu"
-        lit_model = lit_model.to(device)
+        model = model.to(device)
         tensor = tensor.to(device)
 
         with torch.no_grad():
-            outputs = lit_model(tensor)
+            outputs = model(tensor)
             if hasattr(outputs, "logits"):
                 outputs = outputs.logits
             probabilities = torch.softmax(outputs, dim=-1)

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/cli/commands/train.py

@@ -5,10 +5,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 import matplotlib
-import pytorch_lightning as pl
 import torch
-from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
-from pytorch_lightning.loggers import CSVLogger
 
 from deepecgkit.cli.evaluation import _save_multi_label_evaluation, _save_single_label_evaluation
 from deepecgkit.cli.logger import CLILogger
@@ -22,7 +19,7 @@ from deepecgkit.cli.registry import (
 )
 from deepecgkit.datasets import ECGDataModule
 from deepecgkit.evaluation.visualization import plot_training_curves
-from deepecgkit.training import ECGLitModel
+from deepecgkit.training import ECGTrainer
 from deepecgkit.utils.weights import load_pretrained_weights
 
 
@@ -65,7 +62,8 @@ def train(
         logger.info(f"Available datasets: {', '.join(DATASET_NAMES)}")
         return 1
 
-    pl.seed_everything(seed)
+    ECGTrainer.seed_everything(seed)
+    torch.set_float32_matmul_precision("medium")
 
     if output_dir is None:
         timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
@@ -124,7 +122,6 @@ def train(
     if binary_classification and dataset_name in af_datasets:
         num_classes = 2
 
-    # BCE loss expects a single logit output for binary classification
     model_output_size = (
         1 if (binary_classification and dataset_name in af_datasets) else num_classes
     )
@@ -177,41 +174,25 @@ def train(
         "pos_weight": pos_weight,
     }
 
-    lit_model = ECGLitModel(model=model, train_config=train_config)
+    trainer = ECGTrainer(model=model, train_config=train_config, device=accelerator)
 
-    checkpoint_callback = ModelCheckpoint(
-        dirpath=output_path / "checkpoints",
-        filename=f"{model_name}-{dataset_name}-{{epoch:02d}}-{{val_loss:.4f}}",
-        monitor="val_loss",
-        mode="min",
-        save_top_k=3,
-    )
-
-    early_stopping = EarlyStopping(
-        monitor="val_loss",
-        patience=early_stopping_patience,
-        mode="min",
-    )
-
-    csv_logger = CSVLogger(save_dir=output_path, name="training_logs")
-
-    trainer = pl.Trainer(
-        max_epochs=epochs,
-        accelerator=accelerator,
-        devices=devices,
-        callbacks=[checkpoint_callback, early_stopping],
-        logger=csv_logger,
-        default_root_dir=output_path,
-        enable_progress_bar=not logger.quiet,
-    )
+    checkpoint_dir = output_path / "checkpoints"
+    log_dir = output_path / "training_logs"
 
     try:
         logger.info(f"Starting training for {epochs} epochs...")
-        trainer.fit(lit_model, data_module)
+        trainer.fit(
+            data_module,
+            epochs=epochs,
+            early_stopping_patience=early_stopping_patience,
+            checkpoint_dir=str(checkpoint_dir),
+            log_dir=str(log_dir),
+            progress_bar=not logger.quiet,
+        )
 
-        if data_module.test_dataloader() is not None:
+        if data_module.test_dataset is not None and len(data_module.test_dataset) > 0:
             logger.info("Running test evaluation...")
-            trainer.test(lit_model, data_module)
+            trainer.test(data_module)
 
         logger.info(f"Training complete. Checkpoints saved to {output_path}")
 
@@ -222,7 +203,7 @@ def train(
             if hasattr(data_module, "dataset") and hasattr(data_module.dataset, "class_names"):
                 class_names = data_module.dataset.class_names
 
-            metrics_file = Path(csv_logger.log_dir) / "metrics.csv"
+            metrics_file = log_dir / "metrics.csv"
             if metrics_file.exists():
                 plot_training_curves(
                     str(metrics_file),
@@ -231,7 +212,7 @@ def train(
                 logger.info(f"Loss plot saved to {output_path / 'loss.png'}")
                 logger.info(f"Accuracy plot saved to {output_path / 'accuracy.png'}")
 
-            y_pred, y_true, y_prob = lit_model.get_test_results()
+            y_pred, y_true, y_prob = trainer.get_test_results()
 
             if y_pred is not None:
                 is_multi_label = y_true.ndim > 1
@@ -273,6 +254,7 @@ def train(
 
 def resume(
     checkpoint: str,
+    model_name: str,
     epochs: Optional[int] = None,
     output_dir: Optional[str] = None,
     accelerator: str = "auto",
@@ -290,42 +272,8 @@ def resume(
 
     try:
         logger.info(f"Loading checkpoint from {checkpoint}...")
-        lit_model = ECGLitModel.load_from_checkpoint(checkpoint)
-
-        output_path = Path(output_dir) if output_dir else checkpoint_path.parent
-        output_path.mkdir(parents=True, exist_ok=True)
-
-        checkpoint_callback = ModelCheckpoint(
-            dirpath=output_path,
-            filename="resumed-{epoch:02d}-{val_loss:.4f}",
-            monitor="val_loss",
-            mode="min",
-            save_top_k=3,
-        )
-
-        early_stopping = EarlyStopping(
-            monitor="val_loss",
-            patience=early_stopping_patience,
-            mode="min",
-        )
-
-        trainer_kwargs: Dict[str, Any] = {
-            "accelerator": accelerator,
-            "devices": devices,
-            "callbacks": [checkpoint_callback, early_stopping],
-            "default_root_dir": output_path,
-            "enable_progress_bar": not logger.quiet,
-        }
-        if epochs:
-            trainer_kwargs["max_epochs"] = epochs
-
-        trainer = pl.Trainer(**trainer_kwargs)
-
-        logger.info("Resuming training...")
-        trainer.fit(lit_model, ckpt_path=checkpoint)
-
-        logger.info(f"Training complete. Checkpoints saved to {output_path}")
-        return 0
+        logger.warning("Resume requires a data_module. Please use the train command instead.")
+        return 1
     except Exception as e:
         logger.error(f"Failed to resume training: {e}")
         return 1

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/cli/main.py

@@ -20,9 +20,9 @@ def main(argv: Optional[list] = None) -> int:
 Examples:
   deepecg train -m kanres -d af-classification
   deepecg train -m kanres -d af-classification --force-download
-  deepecg evaluate --checkpoint model.ckpt -d af-classification
-  deepecg predict --checkpoint model.ckpt --input ecg.npy
-  deepecg resume --checkpoint model.ckpt --epochs 100
+  deepecg evaluate --checkpoint model.ckpt -m kanres -d af-classification
+  deepecg predict --checkpoint model.ckpt -m kanres --input ecg.npy
+  deepecg resume --checkpoint model.ckpt -m kanres --epochs 100
   deepecg list-models
   deepecg info -m kanres
 
@@ -190,6 +190,14 @@ Note: Datasets are automatically downloaded when first used.
         required=True,
         help="Path to model checkpoint",
     )
+    eval_parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        required=True,
+        choices=MODEL_NAMES,
+        help="Model architecture to load",
+    )
     eval_parser.add_argument(
         "--dataset",
         "-d",
@@ -250,6 +258,14 @@ Note: Datasets are automatically downloaded when first used.
         required=True,
         help="Path to model checkpoint",
     )
+    predict_parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        required=True,
+        choices=MODEL_NAMES,
+        help="Model architecture to load",
+    )
     predict_parser.add_argument(
         "--input",
         "-i",
@@ -286,6 +302,14 @@ Note: Datasets are automatically downloaded when first used.
         required=True,
         help="Path to checkpoint to resume from",
     )
+    resume_parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        required=True,
+        choices=MODEL_NAMES,
+        help="Model architecture to load",
+    )
     resume_parser.add_argument(
         "--epochs",
         "-e",
@@ -384,6 +408,7 @@ Note: Datasets are automatically downloaded when first used.
         return _cli.evaluate(
             checkpoint=args.checkpoint,
             dataset_name=args.dataset,
+            model_name=args.model,
             data_dir=args.data_dir,
             batch_size=args.batch_size,
             num_workers=args.num_workers,
@@ -401,12 +426,14 @@ Note: Datasets are automatically downloaded when first used.
             output_path=args.output,
             batch_size=args.batch_size,
             accelerator=args.accelerator,
+            model_name=args.model,
             logger=logger,
         )
 
     elif args.command == "resume":
         return _cli.resume(
             checkpoint=args.checkpoint,
+            model_name=args.model,
             epochs=args.epochs,
             output_dir=args.output_dir,
             accelerator=args.accelerator,

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/datasets/modules.py

@@ -1,11 +1,10 @@
 """
-PyTorch Lightning data module for ECG datasets.
+Data module for ECG datasets.
 """
 
 from typing import Dict, Optional, Type, Union
 
 import numpy as np
-import pytorch_lightning as pl
 import torch
 from torch.utils.data import DataLoader, Dataset
 
@@ -13,8 +12,11 @@ from deepecgkit.datasets.base import BaseECGDataset
 from deepecgkit.datasets.splitting import DataSplitter
 
 
-class ECGDataModule(pl.LightningDataModule):
-    """PyTorch Lightning data module for ECG datasets."""
+class ECGDataModule:
+    """Data module for ECG datasets.
+
+    Handles dataset creation, train/val/test splitting, and DataLoader construction.
+    """
 
     def __init__(
         self,
@@ -57,7 +59,6 @@ class ECGDataModule(pl.LightningDataModule):
             stratify: Whether to use stratified splitting based on labels
             dataset_kwargs: Additional keyword arguments to pass to the dataset class
         """
-        super().__init__()
         self.dataset = dataset
         self.dataset_class = dataset_class
         self.data_dir = data_dir

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/evaluation/evaluator.py

@@ -16,9 +16,6 @@ from deepecgkit.evaluation.metrics import (
 )
 
 MAX_CLASSIFICATION_CLASSES = 20
-TUPLE_LENGTH_2 = 2
-TUPLE_LENGTH_3 = 3
-MAX_BRANCHES = 12
 
 
 class ECGEvaluator:
@@ -72,10 +69,7 @@ class ECGEvaluator:
             Dictionary of metric values
         """
 
-        if y_scores is not None:
-            self.y_scores = y_scores
-        else:
-            self.y_scores = None
+        self.y_scores = y_scores
 
         predictions, targets = self._process_input_data(model, test_data)
         metrics = self._calculate_metrics(predictions, targets)
@@ -104,10 +98,10 @@ class ECGEvaluator:
         if not isinstance(test_data, tuple):
             return predictions, test_data
 
-        if len(test_data) == TUPLE_LENGTH_3:
+        if len(test_data) == 3:
             targets = test_data[1]
             self.y_scores = test_data[2]
-        elif len(test_data) == TUPLE_LENGTH_2:
+        elif len(test_data) == 2:
             targets = test_data[1]
         else:
             targets = test_data
@@ -146,7 +140,7 @@ class ECGEvaluator:
 
         if isinstance(test_data, torch.utils.data.DataLoader):
             return self._process_dataloader(model, test_data)
-        elif isinstance(test_data, tuple) and len(test_data) == TUPLE_LENGTH_2:
+        elif isinstance(test_data, tuple) and len(test_data) == 2:
             return self._process_tuple_data(model, test_data)
         elif isinstance(test_data, np.ndarray):
             return self._process_numpy_data(model, test_data)
@@ -155,11 +149,11 @@ class ECGEvaluator:
 
     def _handle_tuple_test_data(self, test_data: tuple) -> tuple:
         """Handle test data when it's a tuple."""
-        if len(test_data) == TUPLE_LENGTH_3:
+        if len(test_data) == 3:
             y_true, y_pred, y_scores = test_data
             self.y_scores = y_scores
             return y_pred, y_true
-        elif len(test_data) == TUPLE_LENGTH_2:
+        elif len(test_data) == 2:
             return test_data[0], test_data[1]
         return test_data, None
 
@@ -171,7 +165,7 @@ class ECGEvaluator:
         targets = []
         with torch.no_grad():
             for batch in test_data:
-                if isinstance(batch, (list, tuple)) and len(batch) == TUPLE_LENGTH_2:
+                if isinstance(batch, (list, tuple)) and len(batch) == 2:
                     x, y = batch
                 else:
                     x, y = batch, None

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/evaluation/visualization.py

@@ -2,7 +2,6 @@
 Visualization functions for ECG evaluation.
 """
 
-import warnings
 from pathlib import Path
 from typing import List, Optional
 
@@ -58,34 +57,30 @@ def plot_roc_curve(
     save_path: Optional[str] = None,
 ):
     """Plot ROC curve."""
-    try:
-        fpr, tpr, _ = roc_curve(y_true, y_scores)
-        roc_auc = auc(fpr, tpr)
-
-        plt.figure(figsize=(8, 6))
-        plt.plot(
-            fpr,
-            tpr,
-            color="darkorange",
-            lw=2,
-            label=f"ROC curve (area = {roc_auc:.2f})",
-        )
-        plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--")
-        plt.xlim([0.0, 1.0])
-        plt.ylim([0.0, 1.05])
-        plt.xlabel("False Positive Rate")
-        plt.ylabel("True Positive Rate")
-        plt.title(title)
-        plt.legend(loc="lower right")
-
-        if save_path:
-            plt.savefig(save_path, dpi=300, bbox_inches="tight")
-            plt.close()
-        else:
-            plt.show()
+    fpr, tpr, _ = roc_curve(y_true, y_scores)
+    roc_auc = auc(fpr, tpr)
+
+    plt.figure(figsize=(8, 6))
+    plt.plot(
+        fpr,
+        tpr,
+        color="darkorange",
+        lw=2,
+        label=f"ROC curve (area = {roc_auc:.2f})",
+    )
+    plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--")
+    plt.xlim([0.0, 1.0])
+    plt.ylim([0.0, 1.05])
+    plt.xlabel("False Positive Rate")
+    plt.ylabel("True Positive Rate")
+    plt.title(title)
+    plt.legend(loc="lower right")
 
-    except ImportError:
-        warnings.warn("Could not plot ROC curve - missing dependencies", stacklevel=2)
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
+        plt.close()
+    else:
+        plt.show()
 
 
 def plot_predictions(

{deepecgkit-0.1.0 → deepecgkit-0.2.0}/deepecgkit/models/transformer_ecg.py

@@ -109,7 +109,7 @@ class TransformerECG(nn.Module):
     def feature_dim(self) -> int:
         return self._feature_dim
 
-    def _extract_encoder_features(self, x: torch.Tensor) -> torch.Tensor:
+    def extract_features(self, x: torch.Tensor) -> torch.Tensor:
         x = x.transpose(1, 2)
         x = self.input_projection(x)
         x = self.positional_encoding(x)
@@ -119,9 +119,6 @@ class TransformerECG(nn.Module):
         x = x.squeeze(-1)
         return x
 
-    def extract_features(self, x: torch.Tensor) -> torch.Tensor:
-        return self._extract_encoder_features(x)
-
     def forward(self, x):
         x = self.extract_features(x)
         return self.classifier(x)

deepecgkit-0.2.0/deepecgkit/training/__init__.py

@@ -0,0 +1,3 @@
+from deepecgkit.training.train import ECGTrainer
+
+__all__ = ["ECGTrainer"]