Upload train_medsiglip.py with huggingface_hub

train_medsiglip.py

@@ -0,0 +1,604 @@
+"""
+LaborView AI - MedSigLIP Training Script
+Fine-tune MedSigLIP vision encoder for ultrasound segmentation
+Self-contained script for HuggingFace Jobs
+"""
+
+# /// script
+# dependencies = [
+#   "torch>=2.0.0",
+#   "transformers>=4.50.0",
+#   "accelerate>=0.27.0",
+#   "albumentations>=1.3.0",
+#   "pillow>=10.0.0",
+#   "numpy>=1.24.0",
+#   "tqdm>=4.65.0",
+#   "huggingface_hub>=0.20.0",
+#   "pandas>=2.0.0",
+#   "opencv-python-headless>=4.8.0",
+# ]
+# ///
+
+import os
+import sys
+import json
+import zipfile
+import urllib.request
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.amp import GradScaler, autocast
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import OneCycleLR
+from torch.utils.data import Dataset, DataLoader
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+
+try:
+    import albumentations as A
+    from albumentations.pytorch import ToTensorV2
+    ALBU_AVAILABLE = True
+except ImportError:
+    ALBU_AVAILABLE = False
+    import torchvision.transforms as T
+
+
+@dataclass
+class Config:
+    # Data
+    data_url: str = "https://zenodo.org/records/17655183/files/DatasetV3.zip?download=1"
+    data_dir: Path = Path("./data")
+    image_size: int = 448  # MedSigLIP native resolution
+
+    # Model - MedSigLIP
+    encoder_name: str = "medsiglip"
+    encoder_pretrained: str = "google/medsiglip-448"
+    encoder_hidden_dim: int = 1152  # SigLIP-Large hidden dim
+    projection_dim: int = 256
+
+    # Task heads
+    num_plane_classes: int = 2
+    num_seg_classes: int = 3  # background, symphysis, head
+
+    # Training
+    batch_size: int = 8  # Smaller batch for larger model
+    num_epochs: int = 30
+    learning_rate: float = 5e-5  # Lower LR for fine-tuning
+    weight_decay: float = 0.01
+    warmup_epochs: int = 2
+    gradient_accumulation: int = 4
+    freeze_encoder_epochs: int = 3  # Freeze encoder initially
+
+    # Output
+    output_dir: Path = Path("./outputs")
+    hub_model_id: str = "samwell/laborview-medsiglip"
+    push_to_hub: bool = True
+    seed: int = 42
+
+
+class UltrasoundDataset(Dataset):
+    """Dataset for ultrasound segmentation"""
+
+    def __init__(self, data_dir: Path, split: str = "train", image_size: int = 448, augment: bool = True):
+        self.data_dir = Path(data_dir)
+        self.split = split
+        self.image_size = image_size
+        self.samples = self._find_samples()
+        print(f"Found {len(self.samples)} samples for {split}")
+        self.transform = self._get_transform(augment and split == "train")
+
+    def _find_samples(self) -> List[Dict]:
+        samples = []
+        seg_dir = self.data_dir / self.split / "seg"
+
+        if not seg_dir.exists():
+            print(f"Warning: {seg_dir} not found")
+            return samples
+
+        for video_dir in seg_dir.iterdir():
+            if not video_dir.is_dir():
+                continue
+
+            # Check for images and masks
+            image_dir = video_dir / "image"
+            mask_dir = video_dir / "mask"
+
+            if mask_dir.exists():
+                for mask_path in mask_dir.glob("*.png"):
+                    # Try to find corresponding image
+                    image_path = None
+                    if image_dir.exists():
+                        potential_image = image_dir / mask_path.name
+                        if potential_image.exists():
+                            image_path = str(potential_image)
+
+                    samples.append({
+                        "mask_path": str(mask_path),
+                        "image_path": image_path,
+                        "video_id": video_dir.name,
+                    })
+
+        return samples
+
+    def _get_transform(self, augment: bool):
+        if ALBU_AVAILABLE:
+            if augment:
+                return A.Compose([
+                    A.Resize(self.image_size, self.image_size),
+                    A.HorizontalFlip(p=0.5),
+                    A.RandomBrightnessContrast(p=0.3),
+                    A.GaussNoise(var_limit=(10, 50), p=0.2),
+                    A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=10, p=0.3),
+                    A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),  # MedSigLIP normalization
+                    ToTensorV2()
+                ])
+            else:
+                return A.Compose([
+                    A.Resize(self.image_size, self.image_size),
+                    A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+                    ToTensorV2()
+                ])
+        else:
+            return T.Compose([
+                T.Resize((self.image_size, self.image_size)),
+                T.ToTensor(),
+                T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+            ])
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        sample = self.samples[idx]
+
+        # Load mask
+        mask = Image.open(sample["mask_path"]).convert("L")
+        mask = np.array(mask)
+
+        # Load or create image from mask
+        if sample["image_path"] and os.path.exists(sample["image_path"]):
+            image = Image.open(sample["image_path"]).convert("RGB")
+            image = np.array(image)
+        else:
+            # Use mask as grayscale image
+            image = np.stack([mask, mask, mask], axis=-1)
+
+        # Convert mask to class labels (0=background, 1=symphysis, 2=head)
+        # Assuming mask has different intensity values for different structures
+        mask_classes = np.zeros_like(mask, dtype=np.int64)
+        mask_classes[mask > 0] = 1  # Any non-zero is foreground
+        mask_classes[mask > 127] = 2  # Higher intensity is second class
+
+        if ALBU_AVAILABLE:
+            transformed = self.transform(image=image, mask=mask_classes)
+            image, mask = transformed["image"], transformed["mask"]
+        else:
+            image = self.transform(Image.fromarray(image))
+            mask = torch.from_numpy(
+                np.array(Image.fromarray(mask_classes.astype(np.uint8)).resize(
+                    (self.image_size, self.image_size), Image.NEAREST
+                ))
+            ).long()
+
+        return {
+            "pixel_values": image,
+            "seg_labels": mask,
+            "plane_labels": torch.tensor(1, dtype=torch.long)  # Standard plane
+        }
+
+
+class SegmentationDecoder(nn.Module):
+    """Decoder for upsampling vision features to segmentation mask"""
+
+    def __init__(self, input_dim: int, num_classes: int, decoder_channels=[512, 256, 128, 64]):
+        super().__init__()
+
+        self.input_proj = nn.Conv2d(input_dim, decoder_channels[0], 1)
+
+        self.up_blocks = nn.ModuleList()
+        in_ch = decoder_channels[0]
+        for out_ch in decoder_channels[1:]:
+            self.up_blocks.append(nn.Sequential(
+                nn.ConvTranspose2d(in_ch, out_ch, 4, stride=2, padding=1),
+                nn.BatchNorm2d(out_ch),
+                nn.GELU()
+            ))
+            in_ch = out_ch
+
+        # Final upsampling to full resolution
+        self.final_up = nn.Sequential(
+            nn.ConvTranspose2d(decoder_channels[-1], 32, 4, stride=2, padding=1),
+            nn.BatchNorm2d(32),
+            nn.GELU(),
+            nn.ConvTranspose2d(32, 32, 4, stride=2, padding=1),
+            nn.BatchNorm2d(32),
+            nn.GELU(),
+        )
+
+        self.classifier = nn.Conv2d(32, num_classes, 1)
+
+    def forward(self, x, target_size=None):
+        B = x.shape[0]
+
+        # Handle different input shapes
+        if x.dim() == 3:
+            # [B, num_patches, hidden_dim] -> [B, hidden_dim, H, W]
+            num_patches = x.shape[1]
+            H = W = int(num_patches ** 0.5)
+            x = x.transpose(1, 2).reshape(B, -1, H, W)
+
+        x = self.input_proj(x)
+
+        for block in self.up_blocks:
+            x = block(x)
+
+        x = self.final_up(x)
+        x = self.classifier(x)
+
+        if target_size:
+            x = F.interpolate(x, size=target_size, mode='bilinear', align_corners=False)
+
+        return x
+
+
+class LaborViewMedSigLIP(nn.Module):
+    """LaborView model with MedSigLIP vision encoder"""
+
+    def __init__(self, config: Config):
+        super().__init__()
+        self.config = config
+
+        # Load MedSigLIP
+        print(f"Loading MedSigLIP from {config.encoder_pretrained}...")
+        from transformers import AutoModel
+
+        self.encoder = AutoModel.from_pretrained(
+            config.encoder_pretrained,
+            trust_remote_code=True
+        )
+
+        # Get vision model from SigLIP
+        if hasattr(self.encoder, 'vision_model'):
+            self.vision_encoder = self.encoder.vision_model
+        else:
+            self.vision_encoder = self.encoder
+
+        # Get hidden dimension from config
+        if hasattr(self.vision_encoder.config, 'hidden_size'):
+            hidden_dim = self.vision_encoder.config.hidden_size
+        else:
+            hidden_dim = config.encoder_hidden_dim
+
+        print(f"Vision encoder hidden dim: {hidden_dim}")
+
+        # Projector for classification
+        self.projector = nn.Sequential(
+            nn.Linear(hidden_dim, config.projection_dim),
+            nn.LayerNorm(config.projection_dim),
+            nn.GELU(),
+            nn.Linear(config.projection_dim, config.projection_dim)
+        )
+
+        # Classification head
+        self.cls_head = nn.Linear(config.projection_dim, config.num_plane_classes)
+
+        # Segmentation decoder
+        self.seg_decoder = SegmentationDecoder(hidden_dim, config.num_seg_classes)
+
+    def forward(self, pixel_values):
+        # Get vision features
+        if hasattr(self, 'vision_encoder'):
+            outputs = self.vision_encoder(pixel_values)
+        else:
+            outputs = self.encoder.get_image_features(pixel_values, return_dict=True)
+
+        # Get hidden states
+        if hasattr(outputs, 'last_hidden_state'):
+            hidden = outputs.last_hidden_state
+        elif hasattr(outputs, 'pooler_output'):
+            hidden = outputs.pooler_output
+        else:
+            hidden = outputs
+
+        # Handle different output formats
+        if hidden.dim() == 2:
+            # [B, hidden_dim] - pooled output
+            pooled = hidden
+            # Create spatial features for segmentation
+            B, D = hidden.shape
+            seq = hidden.unsqueeze(1).expand(B, 32*32, D)
+        elif hidden.dim() == 3:
+            # [B, num_patches, hidden_dim]
+            pooled = hidden.mean(dim=1)
+            seq = hidden
+        else:
+            # [B, D, H, W]
+            B, D, H, W = hidden.shape
+            pooled = hidden.mean(dim=[2, 3])
+            seq = hidden.flatten(2).transpose(1, 2)
+
+        # Classification
+        projected = self.projector(pooled)
+        plane_logits = self.cls_head(projected)
+
+        # Segmentation
+        seg_masks = self.seg_decoder(seq, target_size=pixel_values.shape[-2:])
+
+        return plane_logits, seg_masks
+
+    def compute_loss(self, plane_logits, seg_masks, plane_labels, seg_labels):
+        losses = {}
+
+        # Classification loss
+        if plane_labels is not None:
+            losses["cls"] = F.cross_entropy(plane_logits, plane_labels)
+
+        # Segmentation loss (Dice + CE)
+        if seg_labels is not None:
+            # Cross entropy
+            ce_loss = F.cross_entropy(seg_masks, seg_labels.long())
+
+            # Dice loss
+            seg_probs = F.softmax(seg_masks, dim=1)
+            target_oh = F.one_hot(seg_labels.long(), self.config.num_seg_classes).permute(0, 3, 1, 2).float()
+
+            intersection = (seg_probs * target_oh).sum(dim=(2, 3))
+            union = seg_probs.sum(dim=(2, 3)) + target_oh.sum(dim=(2, 3))
+            dice_loss = 1 - ((2 * intersection + 1e-6) / (union + 1e-6)).mean()
+
+            losses["seg"] = dice_loss + ce_loss
+
+        return sum(losses.values()), losses
+
+    def freeze_encoder(self):
+        """Freeze the vision encoder"""
+        for param in self.vision_encoder.parameters():
+            param.requires_grad = False
+        print("Encoder frozen")
+
+    def unfreeze_encoder(self):
+        """Unfreeze the vision encoder"""
+        for param in self.vision_encoder.parameters():
+            param.requires_grad = True
+        print("Encoder unfrozen")
+
+
+def train_epoch(model, loader, optimizer, scheduler, scaler, device, config, epoch):
+    model.train()
+    total_loss, num_batches = 0, 0
+
+    pbar = tqdm(loader, desc=f"Epoch {epoch+1} Training")
+    for batch_idx, batch in enumerate(pbar):
+        pixel_values = batch["pixel_values"].to(device)
+        seg_labels = batch["seg_labels"].to(device)
+        plane_labels = batch["plane_labels"].to(device)
+
+        with autocast("cuda", enabled=True):
+            plane_logits, seg_masks = model(pixel_values)
+            loss, _ = model.compute_loss(plane_logits, seg_masks, plane_labels, seg_labels)
+
+        loss = loss / config.gradient_accumulation
+        scaler.scale(loss).backward()
+
+        if (batch_idx + 1) % config.gradient_accumulation == 0:
+            scaler.step(optimizer)
+            scaler.update()
+            optimizer.zero_grad()
+            scheduler.step()
+
+        total_loss += loss.item() * config.gradient_accumulation
+        num_batches += 1
+        pbar.set_postfix({"loss": f"{loss.item() * config.gradient_accumulation:.4f}"})
+
+    return total_loss / num_batches
+
+
+@torch.no_grad()
+def validate(model, loader, device):
+    model.eval()
+    total_loss, total_iou, num_batches = 0, 0, 0
+
+    for batch in tqdm(loader, desc="Validating"):
+        pixel_values = batch["pixel_values"].to(device)
+        seg_labels = batch["seg_labels"].to(device)
+        plane_labels = batch["plane_labels"].to(device)
+
+        plane_logits, seg_masks = model(pixel_values)
+        loss, _ = model.compute_loss(plane_logits, seg_masks, plane_labels, seg_labels)
+
+        # Compute IoU
+        seg_preds = seg_masks.argmax(dim=1)
+        intersection = ((seg_preds == 1) & (seg_labels == 1)).sum().item()
+        union = ((seg_preds == 1) | (seg_labels == 1)).sum().item()
+
+        total_loss += loss.item()
+        total_iou += intersection / (union + 1e-6)
+        num_batches += 1
+
+    return total_loss / num_batches, total_iou / num_batches
+
+
+def download_dataset(config):
+    """Download and extract dataset"""
+    config.data_dir.mkdir(parents=True, exist_ok=True)
+    zip_path = config.data_dir / "dataset.zip"
+
+    if not (config.data_dir / "train").exists():
+        print(f"Downloading dataset from {config.data_url}...")
+        urllib.request.urlretrieve(config.data_url, zip_path)
+
+        print("Extracting...")
+        with zipfile.ZipFile(zip_path, 'r') as z:
+            z.extractall(config.data_dir)
+
+        # Handle nested zips
+        inner_zip = config.data_dir / "DatasetV3.zip"
+        if inner_zip.exists():
+            with zipfile.ZipFile(inner_zip, 'r') as z:
+                z.extractall(config.data_dir)
+
+        # Extract split zips
+        dataset_dir = config.data_dir / "DatasetV3"
+        if dataset_dir.exists():
+            for split in ["train", "val", "test"]:
+                for sz in dataset_dir.glob(f"{split}*.zip"):
+                    print(f"Extracting {sz.name}...")
+                    with zipfile.ZipFile(sz, 'r') as z:
+                        z.extractall(dataset_dir)
+
+        # Cleanup
+        zip_path.unlink(missing_ok=True)
+        inner_zip.unlink(missing_ok=True)
+
+    # Return the correct data directory
+    dataset_v3 = config.data_dir / "DatasetV3"
+    if dataset_v3.exists():
+        return dataset_v3
+    return config.data_dir
+
+
+def main():
+    config = Config()
+
+    # Set seeds
+    torch.manual_seed(config.seed)
+    np.random.seed(config.seed)
+
+    # Device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}")
+    if device.type == "cuda":
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+
+    # Download dataset
+    data_dir = download_dataset(config)
+    print(f"Data directory: {data_dir}")
+
+    # Create datasets
+    train_dataset = UltrasoundDataset(data_dir, "train", config.image_size, augment=True)
+    val_dataset = UltrasoundDataset(data_dir, "val", config.image_size, augment=False)
+
+    if len(val_dataset) == 0:
+        print("No validation data, using 10% of train")
+        train_size = int(0.9 * len(train_dataset))
+        train_dataset, val_dataset = torch.utils.data.random_split(
+            train_dataset, [train_size, len(train_dataset) - train_size]
+        )
+
+    train_loader = DataLoader(
+        train_dataset, batch_size=config.batch_size, shuffle=True,
+        num_workers=4, pin_memory=True, drop_last=True
+    )
+    val_loader = DataLoader(
+        val_dataset, batch_size=config.batch_size, shuffle=False,
+        num_workers=4, pin_memory=True
+    )
+
+    print(f"Train: {len(train_dataset)}, Val: {len(val_dataset)}")
+
+    # Create model
+    print(f"Creating model with {config.encoder_name} encoder...")
+    model = LaborViewMedSigLIP(config).to(device)
+
+    # Count parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+
+    # Freeze encoder initially for stable training
+    model.freeze_encoder()
+
+    # Optimizer
+    optimizer = AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=config.learning_rate,
+        weight_decay=config.weight_decay
+    )
+
+    # Scheduler
+    total_steps = len(train_loader) * config.num_epochs
+    scheduler = OneCycleLR(
+        optimizer,
+        max_lr=config.learning_rate,
+        total_steps=total_steps,
+        pct_start=config.warmup_epochs / config.num_epochs
+    )
+
+    # Scaler for mixed precision
+    scaler = GradScaler("cuda")
+
+    # Output directory
+    config.output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Training
+    best_val_loss = float("inf")
+    print("Starting training")
+
+    for epoch in range(config.num_epochs):
+        # Unfreeze encoder after initial epochs
+        if epoch == config.freeze_encoder_epochs:
+            model.unfreeze_encoder()
+            # Recreate optimizer with all parameters
+            optimizer = AdamW(
+                model.parameters(),
+                lr=config.learning_rate * 0.1,  # Lower LR for encoder
+                weight_decay=config.weight_decay
+            )
+            scheduler = OneCycleLR(
+                optimizer,
+                max_lr=config.learning_rate * 0.1,
+                total_steps=len(train_loader) * (config.num_epochs - epoch),
+                pct_start=0.1
+            )
+
+        train_loss = train_epoch(model, train_loader, optimizer, scheduler, scaler, device, config, epoch)
+        val_loss, val_iou = validate(model, val_loader, device)
+
+        print(f"Epoch {epoch+1}/{config.num_epochs}")
+        print(f"  Train: {train_loss:.4f}, Val: {val_loss:.4f}, IoU: {val_iou:.4f}")
+
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": model.state_dict(),
+                "val_loss": val_loss,
+                "val_iou": val_iou,
+                "config": vars(config)
+            }, config.output_dir / "best.pt")
+            print("  >>> New best!")
+
+    # Save final model
+    torch.save({
+        "model_state_dict": model.state_dict(),
+        "config": vars(config)
+    }, config.output_dir / "final.pt")
+
+    # Push to Hub
+    if config.push_to_hub:
+        try:
+            from huggingface_hub import HfApi, create_repo
+            print(f"Pushing to Hub: {config.hub_model_id}")
+            create_repo(config.hub_model_id, exist_ok=True)
+            HfApi().upload_folder(
+                folder_path=str(config.output_dir),
+                repo_id=config.hub_model_id,
+                commit_message=f"LaborView MedSigLIP v1 - IoU: {val_iou:.4f}"
+            )
+            print(f"Uploaded to https://huggingface.co/{config.hub_model_id}")
+        except Exception as e:
+            print(f"Hub upload failed: {e}")
+
+    print(f"Training complete! Best Val Loss: {best_val_loss:.4f}")
+
+
+if __name__ == "__main__":
+    main()