fix: commit src.infrastructure.model code and restrict gitignore model rule to root

.gitignore

@@ -218,4 +218,5 @@ __marimo__/
 
 # Streamlit
 .streamlit/secrets.toml
-model/
+/model/
+/models/

src/infrastructure/model/__init__.py

@@ -0,0 +1 @@
+# Model service subpackage

src/infrastructure/model/cardiogan.py

@@ -0,0 +1,159 @@
+"""
+infrastructure/model/cardiogan.py
+──────────────────────────────────
+CardioGAN U-Net Generator model architecture.
+Strictly defines the PyTorch nn.Module architecture (SRP). No signal preprocessing.
+"""
+from __future__ import annotations
+
+
+def _build_attention_gate_module():
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+
+    class AttentionGate(nn.Module):
+        """Attention gate for 1-D signals on skip connections."""
+
+        def __init__(self, F_l: int, F_g: int, F_int: int):
+            super().__init__()
+            self.W_x = nn.Conv1d(F_l, F_int, kernel_size=1, stride=1, bias=True)
+            self.W_g = nn.Conv1d(F_g, F_int, kernel_size=1, stride=1, bias=True)
+            self.psi = nn.Conv1d(F_int, 1, kernel_size=1, stride=1, bias=True)
+            self.relu = nn.ReLU(inplace=True)
+            self.sigmoid = nn.Sigmoid()
+
+        def forward(self, x_l: torch.Tensor, g: torch.Tensor) -> torch.Tensor:
+            if g.shape[-1] != x_l.shape[-1]:
+                g = F.interpolate(g, size=x_l.shape[-1], mode="nearest")
+            theta_x = self.W_x(x_l)
+            phi_g = self.W_g(g)
+            f = self.relu(theta_x + phi_g)
+            alpha = self.sigmoid(self.psi(f))
+            return x_l * alpha
+
+    return AttentionGate
+
+
+def _build_encoder_block_module():
+    import torch.nn as nn
+
+    class EncoderBlock(nn.Module):
+        """Encoder block: Conv1d -> [GroupNorm] -> LeakyReLU."""
+
+        def __init__(self, in_ch: int, out_ch: int, kernel_size: int = 16,
+                     stride: int = 2, use_norm: bool = True):
+            super().__init__()
+            pad = (kernel_size - 1) // 2
+            self.conv = nn.Conv1d(in_ch, out_ch, kernel_size, stride, pad)
+            self.norm = nn.GroupNorm(1, out_ch) if use_norm else nn.Identity()
+            self.act = nn.LeakyReLU(0.2, inplace=True)
+
+        def forward(self, x):
+            return self.act(self.norm(self.conv(x)))
+
+    return EncoderBlock
+
+
+def _build_decoder_block_module():
+    import torch.nn as nn
+
+    class DecoderBlock(nn.Module):
+        """Decoder block: ConvTranspose1d -> [GroupNorm] -> ReLU."""
+
+        def __init__(self, in_ch: int, out_ch: int, kernel_size: int = 16,
+                     stride: int = 2, use_norm: bool = True):
+            super().__init__()
+            pad = (kernel_size - 1) // 2
+            out_pad = stride - 1 if stride > 1 else 0
+            self.deconv = nn.ConvTranspose1d(
+                in_ch, out_ch, kernel_size, stride, pad, output_padding=out_pad
+            )
+            self.norm = nn.GroupNorm(1, out_ch) if use_norm else nn.Identity()
+            self.act = nn.ReLU(inplace=True)
+
+        def forward(self, x):
+            return self.act(self.norm(self.deconv(x)))
+
+    return DecoderBlock
+
+
+def build_attention_unet_generator():
+    """
+    Build and return a fresh AttentionUNetGenerator instance.
+    """
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+
+    AttentionGate = _build_attention_gate_module()
+    EncoderBlock = _build_encoder_block_module()
+    DecoderBlock = _build_decoder_block_module()
+
+    class AttentionUNetGenerator(nn.Module):
+        """Attention U-Net Generator for CardioGAN."""
+
+        def __init__(self):
+            super().__init__()
+            enc_filters = [64, 128, 256, 512, 512, 512]
+
+            self.enc1 = EncoderBlock(1, enc_filters[0], use_norm=False)
+            self.enc2 = EncoderBlock(enc_filters[0], enc_filters[1])
+            self.enc3 = EncoderBlock(enc_filters[1], enc_filters[2])
+            self.enc4 = EncoderBlock(enc_filters[2], enc_filters[3])
+            self.enc5 = EncoderBlock(enc_filters[3], enc_filters[4])
+            self.enc6 = EncoderBlock(enc_filters[4], enc_filters[5])
+
+            self.attn5 = AttentionGate(enc_filters[4], enc_filters[4], enc_filters[4] // 2)
+            self.attn4 = AttentionGate(enc_filters[3], enc_filters[3], enc_filters[3] // 2)
+            self.attn3 = AttentionGate(enc_filters[2], enc_filters[2], enc_filters[2] // 2)
+            self.attn2 = AttentionGate(enc_filters[1], enc_filters[1], enc_filters[1] // 2)
+            self.attn1 = AttentionGate(enc_filters[0], enc_filters[0], enc_filters[0] // 2)
+
+            self.dec6 = DecoderBlock(enc_filters[5], enc_filters[4])
+            self.dec5 = DecoderBlock(enc_filters[4] * 2, enc_filters[3])
+            self.dec4 = DecoderBlock(enc_filters[3] * 2, enc_filters[2])
+            self.dec3 = DecoderBlock(enc_filters[2] * 2, enc_filters[1])
+            self.dec2 = DecoderBlock(enc_filters[1] * 2, enc_filters[0])
+
+            self.final = nn.Sequential(
+                nn.ConvTranspose1d(enc_filters[0] * 2, 1, kernel_size=16,
+                                   stride=2, padding=7, output_padding=0),
+                nn.Tanh()
+            )
+
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            e1 = self.enc1(x)    # (B, 64,  256)
+            e2 = self.enc2(e1)   # (B, 128, 128)
+            e3 = self.enc3(e2)   # (B, 256, 64)
+            e4 = self.enc4(e3)   # (B, 512, 32)
+            e5 = self.enc5(e4)   # (B, 512, 16)
+            e6 = self.enc6(e5)   # (B, 512, 8)
+
+            d6 = self.dec6(e6)
+            a5 = self.attn5(e5, d6)
+            d5 = self.dec5(torch.cat([self._match(d6, a5), a5], dim=1))
+
+            a4 = self.attn4(e4, d5)
+            d4 = self.dec4(torch.cat([self._match(d5, a4), a4], dim=1))
+
+            a3 = self.attn3(e3, d4)
+            d3 = self.dec3(torch.cat([self._match(d4, a3), a3], dim=1))
+
+            a2 = self.attn2(e2, d3)
+            d2 = self.dec2(torch.cat([self._match(d3, a2), a2], dim=1))
+
+            a1 = self.attn1(e1, d2)
+            out = self.final(torch.cat([self._match(d2, a1), a1], dim=1))
+
+            return out
+
+        @staticmethod
+        def _match(decoder_feat: torch.Tensor, skip_feat: torch.Tensor) -> torch.Tensor:
+            if decoder_feat.shape[-1] != skip_feat.shape[-1]:
+                decoder_feat = F.interpolate(
+                    decoder_feat, size=skip_feat.shape[-1], mode="nearest"
+                )
+            return decoder_feat
+
+    return AttentionUNetGenerator()

src/infrastructure/model/gan_vgtlnet_service.py

@@ -0,0 +1,316 @@
+"""
+infrastructure/model/gan_vgtlnet_service.py
+────────────────────────────────────────────
+GANVGTLNetService — production AI inference pipeline (CardioGAN + VGTL-Net).
+
+Arsitektur Pipeline (SOLID & Clean):
+    PPG segments (@ 125 Hz, 224 samples/window)
+        │
+        ▼ [CardioGAN Preprocessor] -> SciPy/Numba implementation
+    ┌──────────────────────────────┐
+    │ CardioGANSignalPreprocessor  │  PPG segments -> segmented, filtered [-1, 1] windows @ 128 Hz
+    └──────────────┬───────────────┘
+                   │
+                   ▼ [CardioGAN Generator Model (G_E)]
+    ┌──────────────────────────────┐
+    │ AttentionUNetGenerator       │  PPG windows -> synthetic ECG windows @ 128 Hz
+    └──────────────┬───────────────┘
+                   │
+                   ▼ [CardioGAN Postprocessor]
+    ┌──────────────────────────────┐
+    │ CardioGANSignalPreprocessor  │  synthetic ECG windows @ 128 Hz -> aligned windows @ 125 Hz
+    └──────────────┬───────────────┘
+                   │
+                   ▼ [VGTL-Net Preprocessor]
+    ┌──────────────────────────────┐
+    │ VGTLNetSignalPreprocessor    │  PPG + ECG windows @ 125 Hz -> VG Adjacency RGB Tensor
+    └──────────────┬───────────────┘
+                   │
+                   ▼ [VGTL-Net Predictor Model]
+    ┌──────────────────────────────┐
+    │ ConvNeXtV2BPModel            │  RGB Tensor -> (SBP_pred, DBP_pred) -> averaged SBP/DBP
+    └──────────────────────────────┘
+"""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+import numpy as np
+
+from src.domain.entities.prediction import BPPrediction
+from src.domain.exceptions.pipeline_exceptions import ModelInferenceError, PreprocessingError
+from src.domain.interfaces.services.cardiogan_preprocessor import CardioGANSignalPreprocessor
+from src.domain.interfaces.services.vgtlnet_preprocessor import VGTLNetSignalPreprocessor
+from src.domain.interfaces.services.model_service import ModelService
+from src.shared.config import get_settings
+from src.shared.constants import (
+    MODEL_VERSION_GAN_VGTLNET,
+    BP_SBP_MIN,
+    BP_SBP_MAX,
+    BP_DBP_MIN,
+    BP_DBP_MAX,
+)
+from src.shared.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class GANVGTLNetService(ModelService):
+    """
+    Production model service that orchestrates CardioGAN and VGTL-Net models.
+
+    Adheres fully to SOLID:
+    - SRP: Only orchestrates model loading and execution. Preprocessing is delegated.
+    - DIP: Depends entirely on abstract preprocessor interfaces, not concrete classes.
+    """
+
+    def __init__(
+        self,
+        gan_preprocessor: Optional[CardioGANSignalPreprocessor] = None,
+        vgtlnet_preprocessor: Optional[VGTLNetSignalPreprocessor] = None,
+        gan_checkpoint_path: Optional[str] = None,
+        vgtlnet_checkpoint_path: Optional[str] = None,
+    ) -> None:
+        settings = get_settings()
+        self._gan_path = Path(gan_checkpoint_path or settings.gan_checkpoint_path)
+        self._vgtlnet_path = Path(vgtlnet_checkpoint_path or settings.vgtlnet_checkpoint_path)
+
+        # Lazy import defaults if not provided (retains ease of use + testing flexibility)
+        if gan_preprocessor is None:
+            from src.infrastructure.processing.scipy_cardiogan_preprocessor import SciPyCardioGANPreprocessor
+            self._gan_preprocessor: CardioGANSignalPreprocessor = SciPyCardioGANPreprocessor()
+        else:
+            self._gan_preprocessor = gan_preprocessor
+
+        if vgtlnet_preprocessor is None:
+            from src.infrastructure.processing.numba_vgtlnet_preprocessor import NumbaVGTLNetPreprocessor
+            self._vgtlnet_preprocessor: VGTLNetSignalPreprocessor = NumbaVGTLNetPreprocessor()
+        else:
+            self._vgtlnet_preprocessor = vgtlnet_preprocessor
+
+        self._gan_model: Optional[Any] = None        # AttentionUNetGenerator (G_E)
+        self._vgtlnet_model: Optional[Any] = None    # ConvNeXtV2BPModel
+        self._loaded = False
+        self._device: str = "cpu"
+
+    # ── ModelService interface ────────────────────────────────────────────────
+
+    async def load_model(self) -> None:
+        """
+        Loads CardioGAN and VGTL-Net weights from disk.
+        """
+        if self._loaded:
+            return
+
+        try:
+            import torch
+            from src.infrastructure.model.cardiogan import build_attention_unet_generator
+            from src.infrastructure.model.vgtlnet import build_convnextv2_bp_model
+
+            self._device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info("GANVGTLNetService.load_model() - device=%s", self._device)
+
+            # 1. Load CardioGAN (G_E: PPG -> ECG)
+            if not self._gan_path.exists():
+                raise ModelInferenceError(
+                    "CardioGAN",
+                    f"Checkpoint not found at: {self._gan_path}. "
+                    "Ensure weights are downloaded or set USE_MOCK_MODEL=true."
+                )
+
+            logger.info("Loading CardioGAN from %s ...", self._gan_path)
+            self._gan_model = build_attention_unet_generator()
+            ckpt = torch.load(self._gan_path, map_location=self._device)
+
+            if isinstance(ckpt, dict) and "G_E" in ckpt:
+                state_dict = ckpt["G_E"]
+            elif isinstance(ckpt, dict) and all(
+                k.startswith(("enc", "dec", "attn", "final")) for k in list(ckpt.keys())[:5]
+            ):
+                state_dict = ckpt
+            else:
+                state_dict = ckpt
+
+            self._gan_model.load_state_dict(state_dict, strict=True)
+            self._gan_model.to(self._device)
+            self._gan_model.eval()
+
+            # 2. Load VGTL-Net (ConvNeXt V2 BP Model)
+            if not self._vgtlnet_path.exists():
+                raise ModelInferenceError(
+                    "VGTLNet",
+                    f"Checkpoint not found at: {self._vgtlnet_path}. "
+                    "Ensure weights are downloaded or set USE_MOCK_MODEL=true."
+                )
+
+            logger.info("Loading VGTL-Net from %s ...", self._vgtlnet_path)
+            self._vgtlnet_model = build_convnextv2_bp_model(pretrained=False)
+            vgtl_ckpt = torch.load(self._vgtlnet_path, map_location=self._device)
+
+            if isinstance(vgtl_ckpt, dict) and "model_state_dict" in vgtl_ckpt:
+                vgtl_state = vgtl_ckpt["model_state_dict"]
+            elif isinstance(vgtl_ckpt, dict) and "state_dict" in vgtl_ckpt:
+                vgtl_state = vgtl_ckpt["state_dict"]
+            else:
+                vgtl_state = vgtl_ckpt
+
+            if any(k.startswith("module.") for k in vgtl_state.keys()):
+                vgtl_state = {k[len("module."):]: v for k, v in vgtl_state.items()}
+
+            self._vgtlnet_model.load_state_dict(vgtl_state, strict=True)
+            self._vgtlnet_model.to(self._device)
+            self._vgtlnet_model.eval()
+
+            self._loaded = True
+            logger.info("GANVGTLNetService initialized successfully on %s", self._device)
+
+        except Exception as e:
+            if isinstance(e, ModelInferenceError):
+                raise e
+            raise ModelInferenceError("Initialization", f"Unexpected error while loading models: {e}") from e
+
+    async def predict(
+        self,
+        ppg_signal_id: str,
+        segments: np.ndarray,
+    ) -> BPPrediction:
+        """
+        Executes the full pipeline:
+            Ingested PPG -> Preprocessing -> CardioGAN translation (aligned) ->
+            VG Adjacency extraction -> VGTL-Net raw prediction ->
+            Simulated Annealing threshold optimization -> BPPrediction
+        """
+        if not self._loaded:
+            await self.load_model()
+
+        start = time.perf_counter()
+
+        try:
+            # 1. CardioGAN Pipeline (PPG -> synthetic ECG, both aligned at 125 Hz, 224 samples)
+            ppg_segments_224, ecg_segments_224 = self._run_gan_inference_aligned(segments)
+
+            # 2. VGTL-Net Raw Predictions
+            sbp_preds, dbp_preds = self._run_vgtlnet_raw_predictions(ppg_segments_224, ecg_segments_224)
+
+            # 3. Simulated Annealing Optimization (1000 steps)
+            from src.infrastructure.processing.sa_helpers import run_simulated_annealing
+
+            sa_result = run_simulated_annealing(
+                ppg_segments=ppg_segments_224,
+                ecg_segments=ecg_segments_224,
+                sbp_preds=sbp_preds,
+                dbp_preds=dbp_preds,
+                n_steps=1000,
+            )
+
+            # 4. Filter predictions based on optimized thresholds
+            clean_indices = sa_result["clean_indices"]
+            if len(clean_indices) > 0:
+                sbp = float(np.mean(sbp_preds[clean_indices]))
+                dbp = float(np.mean(dbp_preds[clean_indices]))
+            else:
+                sbp = float(np.mean(sbp_preds))
+                dbp = float(np.mean(dbp_preds))
+
+            # Assemble SA logs
+            sa_log = {
+                "optimal_lo": sa_result["optimal_lo"],
+                "optimal_hi": sa_result["optimal_hi"],
+                "optimal_max_plateau": sa_result["optimal_max_plateau"],
+                "best_loss": sa_result["best_loss"],
+                "initial_loss": sa_result["initial_loss"],
+                "n_total_segments": sa_result["n_total_segments"],
+                "n_clean_segments": sa_result["n_clean_segments"],
+                "yield_rate": sa_result["yield_rate"],
+                "history": sa_result["history"],
+            }
+
+            elapsed_ms = (time.perf_counter() - start) * 1000
+
+            logger.info(
+                "Inference complete (SA optimized) - signal_id=%s, segments=%d (clean=%d) "
+                "SBP=%.1f mmHg, DBP=%.1f mmHg (%.1f ms)",
+                ppg_signal_id, len(ppg_segments_224), len(clean_indices), sbp, dbp, elapsed_ms,
+            )
+
+            return BPPrediction(
+                ppg_signal_id=ppg_signal_id,
+                predicted_sbp=round(float(sbp), 1),
+                predicted_dbp=round(float(dbp), 1),
+                model_version=self.model_version,
+                inference_time_ms=round(elapsed_ms, 2),
+                sa_log=sa_log,
+            )
+
+        except (PreprocessingError, ModelInferenceError) as e:
+            logger.error("Pipeline failure for signal %s: %s", ppg_signal_id, e)
+            raise e
+        except Exception as e:
+            logger.error("Unexpected error in prediction pipeline: %s", e)
+            raise ModelInferenceError("PipelineOrchestration", f"Prediction execution failed: {e}") from e
+
+    def is_loaded(self) -> bool:
+        return self._loaded
+
+    @property
+    def model_version(self) -> str:
+        return MODEL_VERSION_GAN_VGTLNET
+
+    # ── Private Inference Execution ───────────────────────────────────────────
+
+    def _run_gan_inference_aligned(self, ppg_segments: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        import torch
+
+        assert self._gan_model is not None, "CardioGAN generator model has not been loaded"
+
+        try:
+            # Step 1.1: Preprocess raw ppg windows into CardioGAN segmented, normalized segments
+            # preprocess_ppg handles resample, bandpass butter, z-score, and min-max
+            ppg_wins = self._gan_preprocessor.preprocess_ppg(ppg_segments)
+
+            # Step 1.2: Neural Network inference
+            ppg_tensor = torch.tensor(ppg_wins, dtype=torch.float32).unsqueeze(1).to(self._device)
+            with torch.no_grad():
+                ecg_tensor = self._gan_model(ppg_tensor)
+
+            ecg_128 = ecg_tensor.squeeze(1).cpu().numpy()
+
+            # Step 1.3: Postprocess both ECG and PPG to 125 Hz and 224 samples (aligned)
+            ecg_segments_out = self._gan_preprocessor.postprocess_ecg(ecg_128)
+            ppg_segments_out = self._gan_preprocessor.postprocess_ecg(ppg_wins)
+
+            return ppg_segments_out, ecg_segments_out
+
+        except PreprocessingError as e:
+            raise e
+        except Exception as e:
+            raise ModelInferenceError("CardioGAN", f"Forward pass or post-processing failed: {e}") from e
+
+    def _run_vgtlnet_raw_predictions(
+        self,
+        ppg_segments: np.ndarray,
+        ecg_segments: np.ndarray,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        import torch
+
+        assert self._vgtlnet_model is not None, "VGTL-Net model has not been loaded"
+
+        try:
+            # Step 2.1: Preprocess PPG & ECG segments into Visibility Graph RGB normalise Tensors
+            batch_tensor = self._vgtlnet_preprocessor.preprocess_signals(
+                ppg_segments, ecg_segments
+            )
+
+            # Step 2.2: Neural Network inference
+            batch_device = batch_tensor.to(self._device)
+            with torch.no_grad():
+                sbp_preds, dbp_preds = self._vgtlnet_model(batch_device)
+
+            return sbp_preds.cpu().numpy(), dbp_preds.cpu().numpy()
+
+        except PreprocessingError as e:
+            raise e
+        except Exception as e:
+            raise ModelInferenceError("VGTLNet", f"Forward pass or processing failed: {e}") from e

src/infrastructure/model/mock_model_service.py

@@ -0,0 +1,190 @@
+"""
+infrastructure/model/mock_model_service.py
+───────────────────────────────────────────
+MockModelService — deterministic fake inference for testing and local dev.
+
+Returns physiologically plausible (but fake) BP values without loading
+any model weights or requiring a GPU.
+
+Use case: run the full ETL pipeline locally with USE_MOCK_MODEL=true.
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import time
+
+import numpy as np
+
+from src.domain.entities.prediction import BPPrediction
+from src.domain.interfaces.services.model_service import ModelService
+from src.shared.constants import MODEL_VERSION_MOCK
+from src.shared.logger import get_logger
+
+logger = get_logger(__name__)
+
+# Physiologically plausible reference ranges for mock output
+_SBP_BASE = 115.0   # Normal systolic
+_DBP_BASE = 75.0    # Normal diastolic
+_JITTER = 15.0      # ± range around base values
+
+
+class MockModelService(ModelService):
+    """
+    Deterministic mock model service for testing and local development.
+
+    Given the same ``ppg_signal_id``, it always returns the same BP values
+    (deterministic via hash of the ID) — making tests reproducible.
+    """
+
+    def __init__(self) -> None:
+        self._loaded = False
+
+    # ── ModelService interface ────────────────────────────────────────────────
+
+    async def load_model(self) -> None:
+        """Simulates model loading — just flips a flag."""
+        if self._loaded:
+            return
+        logger.info("MockModelService.load_model() — simulating 100ms load delay")
+        await asyncio.sleep(0.1)  # simulate loading latency
+        self._loaded = True
+        logger.info("MockModelService ready (mock mode).")
+
+    async def predict(
+        self,
+        ppg_signal_id: str,
+        segments: np.ndarray,
+    ) -> BPPrediction:
+        """
+        Return deterministic fake BP values based on the signal ID hash.
+
+        The hash ensures the same ID always gives the same output, making
+        unit tests with MockModelService fully reproducible.
+
+        Args:
+            ppg_signal_id: UUID of the source PPGSignal.
+            segments:      Preprocessed signal segments (shape: N × window).
+
+        Returns:
+            BPPrediction with fake but physiologically valid SBP/DBP.
+        """
+        if not self._loaded:
+            await self.load_model()
+
+        start = time.perf_counter()
+
+        # Deterministic jitter: hash the signal ID to get a repeatable seed
+        hash_bytes = hashlib.sha256(ppg_signal_id.encode()).digest()
+        seed = int.from_bytes(hash_bytes[:4], "big")
+
+        # Determine number of segments (always at least 1)
+        n_segments = segments.shape[0] if len(segments.shape) > 1 and segments.shape[0] > 0 else 1
+
+        # 1. Generate fake segments of size 224 to simulate JIT features computation
+        fake_ppg = np.zeros((n_segments, 224), dtype=np.float32)
+        fake_ecg = np.zeros((n_segments, 224), dtype=np.float32)
+
+        # Populate with deterministic signal + noise + optional plateau
+        for i in range(n_segments):
+            seg_seed = (seed + i) & 0xffffffff
+            rng_seg = np.random.default_rng(seg_seed)
+            t = np.linspace(0, 2 * np.pi, 224)
+            # i%3 == 0: noisy (high entropy), others: clean (low entropy)
+            noise_lvl = 0.5 if (i % 3 == 0) else 0.05
+            fake_ppg[i] = np.sin(t) + rng_seg.normal(0, noise_lvl, 224)
+            fake_ecg[i] = np.sin(t * 2) + rng_seg.normal(0, noise_lvl, 224)
+
+            # i%4 == 0: inject flat lines (plateau)
+            if i % 4 == 0:
+                fake_ppg[i, 50:70] = 0.5
+                fake_ecg[i, 100:120] = -0.5
+
+        # 2. Generate segment predictions
+        sbp_preds = []
+        dbp_preds = []
+        for i in range(n_segments):
+            seg_seed = (seed + i) & 0xffffffff
+            rng_seg = np.random.default_rng(seg_seed)
+            s = float(_SBP_BASE + rng_seg.uniform(-_JITTER, _JITTER))
+            d = float(_DBP_BASE + rng_seg.uniform(-_JITTER / 2, _JITTER / 2))
+            
+            # Add variance to noisy windows
+            if i % 3 == 0:
+                s += rng_seg.uniform(-25, 25)
+                d += rng_seg.uniform(-12, 12)
+                # Clamp within physiological bounds
+                s = max(80.0, min(200.0, s))
+                d = max(40.0, min(120.0, d))
+            
+            if s <= d:
+                s = d + 30.0
+
+            sbp_preds.append(s)
+            dbp_preds.append(d)
+
+        sbp_preds_arr = np.array(sbp_preds)
+        dbp_preds_arr = np.array(dbp_preds)
+
+        # 3. Run Simulated Annealing (1000 steps)
+        from src.infrastructure.processing.sa_helpers import run_simulated_annealing
+
+        sa_result = run_simulated_annealing(
+            ppg_segments=fake_ppg,
+            ecg_segments=fake_ecg,
+            sbp_preds=sbp_preds_arr,
+            dbp_preds=dbp_preds_arr,
+            n_steps=1000,
+        )
+
+        clean_indices = sa_result["clean_indices"]
+        if len(clean_indices) > 0:
+            sbp = float(np.mean(sbp_preds_arr[clean_indices]))
+            dbp = float(np.mean(dbp_preds_arr[clean_indices]))
+        else:
+            sbp = float(np.mean(sbp_preds_arr))
+            dbp = float(np.mean(dbp_preds_arr))
+
+        # Assemble SA log dict
+        sa_log = {
+            "optimal_lo": sa_result["optimal_lo"],
+            "optimal_hi": sa_result["optimal_hi"],
+            "optimal_max_plateau": sa_result["optimal_max_plateau"],
+            "best_loss": sa_result["best_loss"],
+            "initial_loss": sa_result["initial_loss"],
+            "n_total_segments": sa_result["n_total_segments"],
+            "n_clean_segments": sa_result["n_clean_segments"],
+            "yield_rate": sa_result["yield_rate"],
+            "history": sa_result["history"],
+        }
+
+        # Simulate short inference time
+        await asyncio.sleep(0.05)
+        elapsed_ms = (time.perf_counter() - start) * 1000
+
+        logger.info(
+            "MockModelService.predict() — signal_id=%s segments=%d (clean=%d) "
+            "SBP=%.1f DBP=%.1f (%.1f ms)",
+            ppg_signal_id,
+            n_segments,
+            len(clean_indices),
+            sbp,
+            dbp,
+            elapsed_ms,
+        )
+
+        return BPPrediction(
+            ppg_signal_id=ppg_signal_id,
+            predicted_sbp=round(sbp, 1),
+            predicted_dbp=round(dbp, 1),
+            model_version=self.model_version,
+            inference_time_ms=round(elapsed_ms, 2),
+            sa_log=sa_log,
+        )
+
+    def is_loaded(self) -> bool:
+        return self._loaded
+
+    @property
+    def model_version(self) -> str:
+        return MODEL_VERSION_MOCK

src/infrastructure/model/vgtlnet.py

@@ -0,0 +1,67 @@
+"""
+infrastructure/model/vgtlnet.py
+────────────────────────────────
+VGTL-Net Model Architecture.
+Strictly defines the PyTorch BP prediction architecture (SRP). No signal preprocessing.
+"""
+from __future__ import annotations
+
+
+def build_bp_mlp(in_features: int):
+    """
+    MLP head for SBP or DBP prediction.
+    """
+    import torch.nn as nn
+    return nn.Sequential(
+        nn.Linear(in_features, 1024),
+        nn.BatchNorm1d(1024),
+        nn.ReLU(inplace=True),
+        nn.Dropout(0.3),
+        nn.Linear(1024, 512),
+        nn.BatchNorm1d(512),
+        nn.ReLU(inplace=True),
+        nn.Dropout(0.2),
+        nn.Linear(512, 1),
+    )
+
+
+def build_convnextv2_bp_model(pretrained: bool = False):
+    """
+    Build ConvNeXtV2BPModel (VGTL-Net backbone + dual MLP head).
+    """
+    try:
+        import timm
+        import torch.nn as nn
+
+        class ConvNeXtV2BPModel(nn.Module):
+            """VGTL-Net: ConvNeXt V2 Tiny + Dual MLP Head for SBP/DBP."""
+
+            def __init__(self, pretrained: bool = False):
+                super().__init__()
+                self.feature_extractor = timm.create_model(
+                    "convnextv2_tiny.fcmae_ft_in22k_in1k",
+                    pretrained=pretrained,
+                    num_classes=0,
+                    global_pool="avg",
+                )
+                feat_dim = self.feature_extractor.num_features  # 768
+                self.mlp_sbp = build_bp_mlp(feat_dim)
+                self.mlp_dbp = build_bp_mlp(feat_dim)
+
+            def forward(self, x):
+                """
+                Args:
+                    x: (B, 3, 224, 224) visibility graph image tensor
+                Returns:
+                    Tuple (sbp_pred, dbp_pred)
+                """
+                feat = self.feature_extractor(x)
+                return self.mlp_sbp(feat).squeeze(-1), self.mlp_dbp(feat).squeeze(-1)
+
+        return ConvNeXtV2BPModel(pretrained=pretrained)
+
+    except ImportError as e:
+        raise RuntimeError(
+            f"Dependencies for VGTL-Net model are missing: {e}. "
+            "Please run: pip install timm"
+        ) from e