![\"\"](\"https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F2848721%2F1314856109fa4672e8b6ded6a3a4a12a%2Fpipeline.jpg?generation=1769129908598386&alt=media\")
Thanks to the organizers for this interesting competition! Here's a summary of our approach.
\nOur solution is based on an End-to-End (E2E) deep learning pipeline that directly predicts ECG time-series signals from ECG images. The key insight was to combine image segmentation with signal refinement in a single differentiable pipeline.
\n
ECG Image (Stage 1 preprocessed)\n │ [H=1280, W=5600, C=3]\n ↓\nStage 2: UNet Segmentation (4-channel soft mask)\n │ [H=1280, W=5600, C=4]\n │ ← Aux Loss 1: Segmentation BCE Loss\n ↓\nDifferentiable Centroid Extraction (mask → 1D signal)\n │ [C=4, L=10250]\n │ ← Aux Loss 2: Signal Centroid L1 Loss\n ↓\nStage 3: 1D ResUNet Refinement\n │ [C=4, L=10250]\n │ ← Main Loss: L1 + SNR Loss\n ↓\nResampling Ensemble (decimate_fir + polyphase + linear)\n │ [C=4, L=fs×10] (e.g., 5000 for fs=500Hz)\n ↓\nFinal ECG Signal (12 leads)\nThis was a key component that enabled end-to-end training:
\n# For each column, compute weighted centroid of the probability distribution\ny_coords = torch.arange(H).view(1, 1, H, 1)\nprob_sum = seg_prob.sum(dim=2) + eps\ncentroid_y = (seg_prob * y_coords).sum(dim=2) / prob_sum\n\n# Convert pixel position to mV\nsignal_mv = (base_y_position - centroid_y) / y_scale\nThis allows gradients to flow from the signal loss back through the segmentation network.
\nCombined segmentation and signal losses with scheduled weighting:
\n# Early training: focus on segmentation\n# Later training: shift focus to signal quality\nseg_weight = seg_start + (seg_end - seg_start) * progress\nsignal_weight = sig_start + (sig_end - sig_start) * progress\n\nloss = seg_weight * seg_bce_loss + signal_weight * (l1_loss + snr_loss)\nAugmentation was crucial for generalization:
\n| Augmentation | \nProbability | \nImpact | \n
|---|---|---|
| Horizontal Flip | \n0.5 | \n+0.6 dB (biggest improvement!) | \n
| Grayscale | \n0.2 | \nHelps with color variation | \n
| Brightness/Contrast | \n0.3 | \nRobustness to lighting | \n
| JPEG Compression | \n0.2 | \nHandles low-quality scans | \n
| Cutout | \n0.2 | \nHandles occlusions/damage | \n
| Gaussian Noise | \n0.2 | \nHandles sensor noise | \n
The horizontal flip augmentation was surprisingly effective (+0.6 dB), likely because it doubled the effective training data and helped the model learn orientation-invariant features.
\nWe trained multiple models with different configurations:
\n| Model | \nEncoder | \nStage3 | \nhflip | \nLB Score(w/o Resampling Ensemble) | \n
|---|---|---|---|---|
| m009 | \nResNet34 | \nresunet1d (d=4) | \n0.0 | \n20.02 | \n
| m010 | \nEfficientNet-B3 | \nresunet1d (d=4) | \n0.0 | \n20.21 | \n
| m013 | \nResNet34 | \nresunet1d (d=4) | \n0.5 | \n20.64 | \n
| m014 | \nEfficientNet-B3 | \nresunet1d (d=4) | \n0.5 | \n20.84 | \n
| m018 | \nEfficientNet-B3 | \nresunet1d (d=5) | \n0.5 | \n20.87 | \n
| m020 | \nEfficientNet-B4 | \nresunet1d (d=4) | \n0.5 | \n20.61 | \n
models = ['m009', 'm010', 'm013', 'm014', 'm018', 'm020']\nweights = [0.05, 0.1, 0.2, 0.25, 0.25, 0.15]\nWeighted average based on single-model performance, with slight diversity bonus for different architectures.
\nA subtle but effective technique: ensemble multiple resampling methods when converting from model output length to target sampling frequency.
\nensemble_methods = ['decimate_fir', 'polyphase', 'linear']\nDifferent resampling algorithms introduce different artifacts (especially at signal edges). Averaging them cancels out method-specific artifacts.
\nHuge thanks to @hengck23 for the excellent public notebooks! Our Stage 1 preprocessing is entirely based on hengck23's work, which provided the foundation for our pipeline. The clean, standardized images from Stage 1 were essential for training our E2E model effectively.
\nThanks also to the Kaggle community for the insightful discussions throughout the competition
", "messages": [ { "id": "3395432", "postDate": "01/23/2026 00:59:29", "content": "Thanks to the organizers for this interesting competition! Here's a summary of our approach.
\nOur solution is based on an End-to-End (E2E) deep learning pipeline that directly predicts ECG time-series signals from ECG images. The key insight was to combine image segmentation with signal refinement in a single differentiable pipeline.
\n
ECG Image (Stage 1 preprocessed)\n │ [H=1280, W=5600, C=3]\n ↓\nStage 2: UNet Segmentation (4-channel soft mask)\n │ [H=1280, W=5600, C=4]\n │ ← Aux Loss 1: Segmentation BCE Loss\n ↓\nDifferentiable Centroid Extraction (mask → 1D signal)\n │ [C=4, L=10250]\n │ ← Aux Loss 2: Signal Centroid L1 Loss\n ↓\nStage 3: 1D ResUNet Refinement\n │ [C=4, L=10250]\n │ ← Main Loss: L1 + SNR Loss\n ↓\nResampling Ensemble (decimate_fir + polyphase + linear)\n │ [C=4, L=fs×10] (e.g., 5000 for fs=500Hz)\n ↓\nFinal ECG Signal (12 leads)\nThis was a key component that enabled end-to-end training:
\n# For each column, compute weighted centroid of the probability distribution\ny_coords = torch.arange(H).view(1, 1, H, 1)\nprob_sum = seg_prob.sum(dim=2) + eps\ncentroid_y = (seg_prob * y_coords).sum(dim=2) / prob_sum\n\n# Convert pixel position to mV\nsignal_mv = (base_y_position - centroid_y) / y_scale\nThis allows gradients to flow from the signal loss back through the segmentation network.
\nCombined segmentation and signal losses with scheduled weighting:
\n# Early training: focus on segmentation\n# Later training: shift focus to signal quality\nseg_weight = seg_start + (seg_end - seg_start) * progress\nsignal_weight = sig_start + (sig_end - sig_start) * progress\n\nloss = seg_weight * seg_bce_loss + signal_weight * (l1_loss + snr_loss)\nAugmentation was crucial for generalization:
\n| Augmentation | \nProbability | \nImpact | \n
|---|---|---|
| Horizontal Flip | \n0.5 | \n+0.6 dB (biggest improvement!) | \n
| Grayscale | \n0.2 | \nHelps with color variation | \n
| Brightness/Contrast | \n0.3 | \nRobustness to lighting | \n
| JPEG Compression | \n0.2 | \nHandles low-quality scans | \n
| Cutout | \n0.2 | \nHandles occlusions/damage | \n
| Gaussian Noise | \n0.2 | \nHandles sensor noise | \n
The horizontal flip augmentation was surprisingly effective (+0.6 dB), likely because it doubled the effective training data and helped the model learn orientation-invariant features.
\nWe trained multiple models with different configurations:
\n| Model | \nEncoder | \nStage3 | \nhflip | \nLB Score(w/o Resampling Ensemble) | \n
|---|---|---|---|---|
| m009 | \nResNet34 | \nresunet1d (d=4) | \n0.0 | \n20.02 | \n
| m010 | \nEfficientNet-B3 | \nresunet1d (d=4) | \n0.0 | \n20.21 | \n
| m013 | \nResNet34 | \nresunet1d (d=4) | \n0.5 | \n20.64 | \n
| m014 | \nEfficientNet-B3 | \nresunet1d (d=4) | \n0.5 | \n20.84 | \n
| m018 | \nEfficientNet-B3 | \nresunet1d (d=5) | \n0.5 | \n20.87 | \n
| m020 | \nEfficientNet-B4 | \nresunet1d (d=4) | \n0.5 | \n20.61 | \n
models = ['m009', 'm010', 'm013', 'm014', 'm018', 'm020']\nweights = [0.05, 0.1, 0.2, 0.25, 0.25, 0.15]\nWeighted average based on single-model performance, with slight diversity bonus for different architectures.
\nA subtle but effective technique: ensemble multiple resampling methods when converting from model output length to target sampling frequency.
\nensemble_methods = ['decimate_fir', 'polyphase', 'linear']\nDifferent resampling algorithms introduce different artifacts (especially at signal edges). Averaging them cancels out method-specific artifacts.
\nHuge thanks to @hengck23 for the excellent public notebooks! Our Stage 1 preprocessing is entirely based on hengck23's work, which provided the foundation for our pipeline. The clean, standardized images from Stage 1 were essential for training our E2E model effectively.
\nThanks also to the Kaggle community for the insightful discussions throughout the competition
", "rawMarkdown": "Thanks to the organizers for this interesting competition! Here's a summary of our approach.\n\n---\n\n## Overview\n\nOur solution is based on an **End-to-End (E2E) deep learning pipeline** that directly predicts ECG time-series signals from ECG images. The key insight was to combine image segmentation with signal refinement in a single differentiable pipeline.\n\n---\n\n## Pipeline Architecture\n\n\n\n```\nECG Image (Stage 1 preprocessed)\n │ [H=1280, W=5600, C=3]\n ↓\nStage 2: UNet Segmentation (4-channel soft mask)\n │ [H=1280, W=5600, C=4]\n │ ← Aux Loss 1: Segmentation BCE Loss\n ↓\nDifferentiable Centroid Extraction (mask → 1D signal)\n │ [C=4, L=10250]\n │ ← Aux Loss 2: Signal Centroid L1 Loss\n ↓\nStage 3: 1D ResUNet Refinement\n │ [C=4, L=10250]\n │ ← Main Loss: L1 + SNR Loss\n ↓\nResampling Ensemble (decimate_fir + polyphase + linear)\n │ [C=4, L=fs×10] (e.g., 5000 for fs=500Hz)\n ↓\nFinal ECG Signal (12 leads)\n```\n\n\n### Stage 0/Stage 1: Preprocessing (from hengck23's notebook)\n- We used **hengck23's excellent public notebook** for preprocessing\n- Includes image rotation correction, cropping, and resizing to 5600×1280\n\n### Stage 2: UNet Segmentation\n- **Encoder**: EfficientNet-B3/B4 or ResNet34 (timm pretrained)\n- **Decoder**: UNet with coordinate channels (CoordConv-style)\n- **Output**: 4-channel soft segmentation mask (one per ECG row)\n- **Loss**: BCE with pos_weight=10 for class imbalance\n\n### Differentiable Centroid Conversion\nThis was a key component that enabled end-to-end training:\n\n```python\n# For each column, compute weighted centroid of the probability distribution\ny_coords = torch.arange(H).view(1, 1, H, 1)\nprob_sum = seg_prob.sum(dim=2) + eps\ncentroid_y = (seg_prob * y_coords).sum(dim=2) / prob_sum\n\n# Convert pixel position to mV\nsignal_mv = (base_y_position - centroid_y) / y_scale\n```\n\nThis allows gradients to flow from the signal loss back through the segmentation network.\n\n### Stage 3: 1D ResUNet\n- **Architecture**: Residual 1D UNet\n- **Input/Output**: 4 channels (corresponding to 4 ECG rows)\n- **Depth**: 4-5 levels\n- **Purpose**: Refine the centroid-extracted signal, correct artifacts\n\n---\n\n## Training Strategy\n\n### Loss Function\nCombined segmentation and signal losses with scheduled weighting:\n\n```python\n# Early training: focus on segmentation\n# Later training: shift focus to signal quality\nseg_weight = seg_start + (seg_end - seg_start) * progress\nsignal_weight = sig_start + (sig_end - sig_start) * progress\n\nloss = seg_weight * seg_bce_loss + signal_weight * (l1_loss + snr_loss)\n```\n\n### Key Training Details\n- **Optimizer**: AdamW (lr=0.005, weight_decay=1e-4)\n- **Scheduler**: Cosine annealing (60 epochs schedule, 32 epochs training)\n- **Batch size**: 4 with gradient accumulation (effective batch 16)\n- **Precision**: FP32 (FP16 caused NaN issues)\n- **EMA**: Enabled (decay=0.995)\n- **All-data training**: No validation split for final models\n\n### Data Augmentation\nAugmentation was crucial for generalization:\n\n| Augmentation | Probability | Impact |\n|--------------|-------------|--------|\n| **Horizontal Flip** | 0.5 | **+0.6 dB** (biggest improvement!) |\n| Grayscale | 0.2 | Helps with color variation |\n| Brightness/Contrast | 0.3 | Robustness to lighting |\n| JPEG Compression | 0.2 | Handles low-quality scans |\n| Cutout | 0.2 | Handles occlusions/damage |\n| Gaussian Noise | 0.2 | Handles sensor noise |\n\nThe horizontal flip augmentation was surprisingly effective (+0.6 dB), likely because it doubled the effective training data and helped the model learn orientation-invariant features.\n\n---\n\n## Ensemble Strategy\n\n### Model Diversity\nWe trained multiple models with different configurations:\n\n| Model | Encoder | Stage3 | hflip | LB Score(w/o Resampling Ensemble) |\n|-------|---------|--------|-------|----------|\n| m009 | ResNet34 | resunet1d (d=4) | 0.0 | 20.02 |\n| m010 | EfficientNet-B3 | resunet1d (d=4) | 0.0 | 20.21 |\n| m013 | ResNet34 | resunet1d (d=4) | 0.5 | 20.64 |\n| m014 | EfficientNet-B3 | resunet1d (d=4) | 0.5 | 20.84 |\n| m018 | EfficientNet-B3 | resunet1d (d=5) | 0.5 | 20.87 |\n| m020 | EfficientNet-B4 | resunet1d (d=4) | 0.5 | 20.61 |\n\n### Final Ensemble\n```python\nmodels = ['m009', 'm010', 'm013', 'm014', 'm018', 'm020']\nweights = [0.05, 0.1, 0.2, 0.25, 0.25, 0.15]\n```\n\nWeighted average based on single-model performance, with slight diversity bonus for different architectures.\n\n### Resampling Ensemble\nA subtle but effective technique: **ensemble multiple resampling methods** when converting from model output length to target sampling frequency.\n\n```python\nensemble_methods = ['decimate_fir', 'polyphase', 'linear']\n```\n\nDifferent resampling algorithms introduce different artifacts (especially at signal edges). Averaging them cancels out method-specific artifacts.\n\n---\n\n## What Worked\n\n1. **End-to-end training** - Joint optimization of segmentation and signal extraction was better than separate stages\n2. **Horizontal flip augmentation** - Surprisingly gave +0.6 dB improvement\n3. **EfficientNet encoders** - Consistently +0.2 dB over ResNet\n4. **Deeper Stage3** - depth=5 helped capture longer-range dependencies\n5. **Resampling ensemble** - Reduced edge artifacts\n6. **Model diversity in ensemble** - Mixing architectures and augmentation settings\n\n---\n\n## What Didn't Work\n\n1. **BiLSTM for Stage3** - Worse than ResUNet (-0.9 dB)\n2. **Higher resolution (7200×1280)** - No improvement, slower training\n3. **Larger output_length (15000)** - Marginal improvement not worth complexity\n4. **ConvNeXt encoder** - Training instability issues\n\n\n---\n\n## Acknowledgments\n\n**Huge thanks to [@hengck23](https://www.kaggle.com/hengck23)** for the excellent public notebooks! Our Stage 1 preprocessing is entirely based on hengck23's work, which provided the foundation for our pipeline. The clean, standardized images from Stage 1 were essential for training our E2E model effectively.\n\nThanks also to the Kaggle community for the insightful discussions throughout the competition", "votes": null }, { "id": "3395551", "postDate": "01/23/2026 07:32:16", "content": "Great work! Thank you for sharing. What is the ground-truth (GT) mask used for the segmentation part?
", "rawMarkdown": "Great work! Thank you for sharing. What is the ground-truth (GT) mask used for the segmentation part?", "votes": null }, { "id": "3395675", "postDate": "01/23/2026 12:54:44", "content": "Thank you for the comment!
\nThe GT mask is generated using the render_signal function provided below. The parameters for render_signal were optimized using the following procedure:
remove_grid_extract_ecg.The attached image shows the result after optimization. Since it depends on the accuracy of Stage 1, it is not a strictly precise segmentation mask, but it was sufficient for the loss calculation during the early stages of training.
\n![\"\"](\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2848721%2F4228efafd122f3c0d729a6714c7ba76d%2F2026-01-23%2021.20.19.png?generation=1769170847408910&alt=media\")
def remove_grid_extract_ecg(img, sat_thresh=50, val_thresh=150):\n \"\"\"\n Remove colored grid and extract black ECG lines.\n\n Args:\n img: BGR image\n sat_thresh: Saturation threshold (pixels below this are considered non-colored)\n val_thresh: Value threshold (pixels below this are considered dark)\n\n Returns:\n Binary mask of ECG lines, result image with grid removed\n \"\"\"\n hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n saturation = hsv[:, :, 1]\n value = hsv[:, :, 2]\n\n # Black ECG lines: low saturation AND low value\n ecg_mask = (saturation < sat_thresh) & (value < val_thresh)\n\n # Clean up\n kernel = np.ones((2, 2), np.uint8)\n ecg_mask_clean = cv2.morphologyEx(\n ecg_mask.astype(np.uint8) * 255, cv2.MORPH_CLOSE, kernel\n )\n\n # Create result image\n result = np.ones_like(img) * 255\n result[ecg_mask_clean > 0] = [0, 0, 0]\n\n return ecg_mask_clean, result\n\ndef render_signal(gt, y_positions, y_scale, sigma=3.0):\n \"\"\"\n Render GT signal with 1px per point.\n\n Args:\n gt: 4-channel GT signal (4, signal_len)\n y_positions: Y-coordinates for each row (based on ORIGINAL_SIZE)\n y_scale: Scale in Y direction\n sigma: Standard deviation for Gaussian blur\n\n Returns:\n Rendered image (h, signal_len)\n \"\"\"\n n_rows, signal_len = gt.shape\n h = ORIGINAL_SIZE[1]\n img = np.zeros((h, signal_len), dtype=np.uint8)\n\n current_y_positions = [y for y in y_positions]\n\n for row_idx in range(n_rows):\n signal = gt[row_idx]\n\n # Skip if signal is all zeros (or very small)\n if np.abs(signal).max() < 1e-6:\n continue\n\n y_center = current_y_positions[row_idx]\n\n # Signal scaling (signal=0 corresponds to y_center)\n signal_norm = signal * y_scale\n y_coords = y_center - signal_norm\n y_coords = np.clip(y_coords, 0, h - 1).astype(np.int32)\n\n # Draw 1px per point\n img[y_coords, np.arange(signal_len)] = 255\n\n # --- Step 2: \"Thicken\" lines using Gaussian Blur ---\n if sigma > 0:\n # Kernel size is typically about 6 times sigma (must be odd)\n k_size = int(6 * sigma) | 1 # Hack to ensure odd number\n\n # Blur in both X and Y directions with (k_size, k_size)\n # *Note: Change to (1, k_size) if you want to preserve sharpness in the X direction (time axis).\n img = cv2.GaussianBlur(img, (1, k_size), sigma)\n\n # --- Step 3: Intensity Normalization ---\n # Since blurring reduces peak values below 255, restore max value to 255.\n # Without this, the balance of the Dice coefficient (numerator/denominator) might be skewed.\n max_val = img.max()\n if max_val > 0:\n img = (img.astype(np.float32) / max_val * 255).astype(np.uint8)\n\n return img\nGreat work! Thank you for sharing. What is the ground-truth (GT) mask used for the segmentation part?
", "votes": null, "replies": [ { "id": 3395675, "author_name": "maruichi01", "author_url": "", "post_date": "01/23/2026 12:54:44", "content": "Thank you for the comment!
\nThe GT mask is generated using the render_signal function provided below. The parameters for render_signal were optimized using the following procedure:
remove_grid_extract_ecg.The attached image shows the result after optimization. Since it depends on the accuracy of Stage 1, it is not a strictly precise segmentation mask, but it was sufficient for the loss calculation during the early stages of training.
\n
def remove_grid_extract_ecg(img, sat_thresh=50, val_thresh=150):\n \"\"\"\n Remove colored grid and extract black ECG lines.\n\n Args:\n img: BGR image\n sat_thresh: Saturation threshold (pixels below this are considered non-colored)\n val_thresh: Value threshold (pixels below this are considered dark)\n\n Returns:\n Binary mask of ECG lines, result image with grid removed\n \"\"\"\n hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n saturation = hsv[:, :, 1]\n value = hsv[:, :, 2]\n\n # Black ECG lines: low saturation AND low value\n ecg_mask = (saturation < sat_thresh) & (value < val_thresh)\n\n # Clean up\n kernel = np.ones((2, 2), np.uint8)\n ecg_mask_clean = cv2.morphologyEx(\n ecg_mask.astype(np.uint8) * 255, cv2.MORPH_CLOSE, kernel\n )\n\n # Create result image\n result = np.ones_like(img) * 255\n result[ecg_mask_clean > 0] = [0, 0, 0]\n\n return ecg_mask_clean, result\n\ndef render_signal(gt, y_positions, y_scale, sigma=3.0):\n \"\"\"\n Render GT signal with 1px per point.\n\n Args:\n gt: 4-channel GT signal (4, signal_len)\n y_positions: Y-coordinates for each row (based on ORIGINAL_SIZE)\n y_scale: Scale in Y direction\n sigma: Standard deviation for Gaussian blur\n\n Returns:\n Rendered image (h, signal_len)\n \"\"\"\n n_rows, signal_len = gt.shape\n h = ORIGINAL_SIZE[1]\n img = np.zeros((h, signal_len), dtype=np.uint8)\n\n current_y_positions = [y for y in y_positions]\n\n for row_idx in range(n_rows):\n signal = gt[row_idx]\n\n # Skip if signal is all zeros (or very small)\n if np.abs(signal).max() < 1e-6:\n continue\n\n y_center = current_y_positions[row_idx]\n\n # Signal scaling (signal=0 corresponds to y_center)\n signal_norm = signal * y_scale\n y_coords = y_center - signal_norm\n y_coords = np.clip(y_coords, 0, h - 1).astype(np.int32)\n\n # Draw 1px per point\n img[y_coords, np.arange(signal_len)] = 255\n\n # --- Step 2: \"Thicken\" lines using Gaussian Blur ---\n if sigma > 0:\n # Kernel size is typically about 6 times sigma (must be odd)\n k_size = int(6 * sigma) | 1 # Hack to ensure odd number\n\n # Blur in both X and Y directions with (k_size, k_size)\n # *Note: Change to (1, k_size) if you want to preserve sharpness in the X direction (time axis).\n img = cv2.GaussianBlur(img, (1, k_size), sigma)\n\n # --- Step 3: Intensity Normalization ---\n # Since blurring reduces peak values below 255, restore max value to 255.\n # Without this, the balance of the Dice coefficient (numerator/denominator) might be skewed.\n max_val = img.max()\n if max_val > 0:\n img = (img.astype(np.float32) / max_val * 255).astype(np.uint8)\n\n return img\n