初始上传：珊瑚语义分割项目（代码+模型+数据）

README.md

@@ -0,0 +1,138 @@
+---
+tags:
+  - image-segmentation
+  - semantic-segmentation
+  - coral
+  - underwater
+  - pytorch
+  - convnext
+  - mask2former
+license: mit
+language:
+  - zh
+---
+
+# 珊瑚语义分割（Coral Segmentation）
+
+水下珊瑚遥感图像语义分割项目，采用 **Mask2Former-Swin-B + ConvNeXt-L-FPN** 双模型融合方案，将 `256×256` RGB 水下图像分割为四类：
+
+| 类别编号 | 类别名称 | 说明 |
+|---------|---------|------|
+| 0 | 背景 | 非珊瑚区域 |
+| 1 | 活珊瑚 | 健康存活的珊瑚 |
+| 2 | 死珊瑚 | 已死亡的珊瑚 |
+| 3 | 白化珊瑚 | 白化状态的珊瑚 |
+
+## 项目结构
+
+```
+coral-segmentation/
+├── coral_seg/                  # 核心代码与模型
+│   ├── coral_seg/              # Python 包（数据集、模型、损失函数）
+│   ├── configs/                # 训练配置（final_dual.yaml）
+│   ├── tools/                  # 训练、推理、评测、可视化脚本
+│   ├── pretrained/             # 预训练权重
+│   ├── work_dirs/              # 训练好的模型 checkpoint
+│   ├── splits/                 # 训练/验证集划分
+│   ├── vis_results/            # 可视化结果示例
+│   ├── submissions/            # 推理输出（results.zip）
+│   ├── docs/                   # 技术报告与操作指南
+│   └── logs/                   # 训练日志
+├── data_fresh/                 # 原始数据
+│   ├── train_bsdtar/           # 训练数据
+│   └── test_raw/               # 测试数据
+└── README.md
+```
+
+## 模型方案
+
+### ConvNeXt-L-FPN
+
+- **骨干网络**：ConvNeXt-Large（ImageNet-1K 预训练）
+- **解码器**：FPN（Feature Pyramid Network），四尺度特征融合
+- **输入尺寸**：512×512
+- **训练**：120 epochs，AdamW，lr=6e-5，混合精度
+
+### Mask2Former-Swin-B
+
+- **骨干网络**：Swin Transformer Base（ADE20K 预训练）
+- **解码器**：Mask2Former mask classification
+- **输入尺寸**：384×384
+- **训练**：80 epochs，AdamW，lr=3e-5，梯度检查点
+
+### 融合推理
+
+```
+prob = 0.55 × prob_mask2former + 0.45 × prob_convnext
+pred = argmax(prob)
+```
+
+支持 TTA（原图 + 水平翻转）。
+
+## 环境安装
+
+```bash
+pip install -r coral_seg/requirements.txt
+```
+
+主要依赖：
+
+- PyTorch 2.3.0
+- Transformers 4.46.3
+- timm 1.0.27
+- albumentations 2.0.8
+
+## 快速开始
+
+### 1. 检查数据
+
+```bash
+python coral_seg/tools/check_data.py --config coral_seg/configs/final_dual.yaml
+```
+
+### 2. 训练 ConvNeXt-L-FPN
+
+```bash
+python coral_seg/tools/train_convnext.py --config coral_seg/configs/final_dual.yaml
+```
+
+### 3. 训练 Mask2Former-Swin-B
+
+```bash
+python coral_seg/tools/train_mask2former.py --config coral_seg/configs/final_dual.yaml
+```
+
+### 4. 融合推理
+
+```bash
+python coral_seg/tools/infer_ensemble.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --convnext-checkpoint coral_seg/work_dirs/convnext_l_fpn/best.pth \
+  --mask2former-checkpoint coral_seg/work_dirs/mask2former_swin_b/best_hf
+```
+
+### 5. 验证集评测
+
+```bash
+python coral_seg/tools/eval_ensemble_val.py --config coral_seg/configs/final_dual.yaml
+```
+
+## 训练策略
+
+- **损失函数**：CE + Dice + 0.5×Lovasz（ConvNeXt）；Mask2Former 内置组合损失
+- **Label Smoothing**：0.05
+- **学习率调度**：warmup + cosine decay
+- **骨干网络低学习率**：ConvNeXt backbone 使用 0.25× 基础学习率
+- **数据增强**：翻转、旋转、仿射变换、亮度/对比度/饱和度扰动、CLAHE、高斯模糊、运动模糊
+
+## 复现条件
+
+- GPU：A30 24GB（或同等显存）
+- 训练+推理总时间 < 24 小时
+- 固定随机种子（seed: 2026）
+- 固定 train/val split
+
+## 文档
+
+- [操作指南](coral_seg/docs/operation-guide.md) — 完整的部署、训练、推理流程
+- [技术报告](coral_seg/docs/technical-report.md) — 算法设计、模型选择、损失函数等技术细节

coral_seg/README.md

@@ -0,0 +1,106 @@
+# 珊瑚语义分割项目说明
+
+本项目用于完成水下珊瑚遥感图像语义分割任务，目标是将每张 `256x256` RGB 图像分割为四类：
+
+```text
+0 背景
+1 活珊瑚
+2 死珊瑚
+3 白化珊瑚
+```
+
+当前实现采用双模型融合方案：
+
+```text
+Mask2Former-Swin-B + ConvNeXt-L-FPN
+```
+
+其中：
+
+```text
+Mask2Former-Swin-B 负责复杂区域和全局语义建模
+ConvNeXt-L-FPN 负责局部纹理、边界和卷积稳定性
+最终通过概率加权融合生成 results.zip
+```
+
+## 文档索引
+
+完整操作流程，包括环境部署、数据解压、模型下载、训练、推理、评测和压缩提交：
+
+```text
+docs/operation-guide.md
+```
+
+算法与技术说明，包括模型选择、训练策略、损失函数、数据增强、融合推理和 mIoU 计算原理：
+
+```text
+docs/technical-report.md
+```
+
+预训练模型部署详见操作指南第 5 节，当前工程使用的本地路径为：
+
+```text
+coral_seg/pretrained/mask2former-swin-base-ade-semantic/
+coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+## 推荐运行目录
+
+当前配置文件中的数据路径、权重路径和输出路径默认指向：
+
+```text
+/root/autodl-tmp/coral/data_fresh
+/root/autodl-tmp/coral/coral_seg
+```
+
+因此推荐从以下目录执行命令：
+
+```bash
+cd /root/autodl-tmp/coral
+```
+
+## 快速训练与推理
+
+下载或检查预训练模型：
+
+```bash
+python coral_seg/tools/download_pretrained.py --config coral_seg/configs/final_dual.yaml
+```
+
+检查数据：
+
+```bash
+python coral_seg/tools/check_data.py --config coral_seg/configs/final_dual.yaml
+```
+
+训练 ConvNeXt-L-FPN：
+
+```bash
+mkdir -p coral_seg/logs
+python coral_seg/tools/train_convnext.py \
+  --config coral_seg/configs/final_dual.yaml \
+  2>&1 | tee coral_seg/logs/convnext_train.log
+```
+
+训练 Mask2Former-Swin-B：
+
+```bash
+python coral_seg/tools/train_mask2former.py \
+  --config coral_seg/configs/final_dual.yaml \
+  2>&1 | tee coral_seg/logs/mask2former_train.log
+```
+
+融合推理并生成提交文件：
+
+```bash
+python coral_seg/tools/infer_ensemble.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --convnext-checkpoint coral_seg/work_dirs/convnext_l_fpn/best.pth \
+  --mask2former-checkpoint coral_seg/work_dirs/mask2former_swin_b/best_hf
+```
+
+最终提交文件：
+
+```text
+/root/autodl-tmp/coral/coral_seg/submissions/results.zip
+```

coral_seg/configs/final_dual.yaml

@@ -0,0 +1,58 @@
+seed: 2026
+num_classes: 4
+class_names:
+  - background
+  - live_coral
+  - dead_coral
+  - bleached_coral
+
+data:
+  train_images: /root/autodl-tmp/coral/data_fresh/train_bsdtar/train/image
+  train_masks: /root/autodl-tmp/coral/data_fresh/train_bsdtar/train/label
+  test_images: /root/autodl-tmp/coral/data_fresh/test_raw/PrecisionLabel800/images
+  split_dir: /root/autodl-tmp/coral/coral_seg/splits
+  val_ratio: 0.15
+
+train:
+  num_workers: 8
+  amp: true
+  grad_clip_norm: 1.0
+  print_freq: 50
+
+convnext:
+  image_size: 512
+  batch_size: 4
+  epochs: 120
+  lr: 0.00006
+  backbone_lr_mult: 0.25
+  weight_decay: 0.01
+  warmup_epochs: 5
+  pretrained: true
+  pretrained_path: /root/autodl-tmp/coral/coral_seg/pretrained/convnext_large-ea097f82.pth
+  work_dir: /root/autodl-tmp/coral/coral_seg/work_dirs/convnext_l_fpn
+  loss:
+    ce: 1.0
+    dice: 1.0
+    lovasz: 0.5
+    label_smoothing: 0.05
+
+mask2former:
+  image_size: 384
+  batch_size: 2
+  epochs: 80
+  lr: 0.00003
+  weight_decay: 0.05
+  warmup_epochs: 5
+  pretrained_name: facebook/mask2former-swin-base-ade-semantic
+  pretrained_dir: /root/autodl-tmp/coral/coral_seg/pretrained/mask2former-swin-base-ade-semantic
+  gradient_checkpointing: true
+  work_dir: /root/autodl-tmp/coral/coral_seg/work_dirs/mask2former_swin_b
+
+infer:
+  convnext_weight: 0.45
+  mask2former_weight: 0.55
+  convnext_sizes: [512]
+  mask2former_sizes: [384]
+  tta_flips: [none, h]
+  out_dir: /root/autodl-tmp/coral/coral_seg/submissions/results
+  zip_path: /root/autodl-tmp/coral/coral_seg/submissions/results.zip

coral_seg/coral_seg/__init__.py

@@ -0,0 +1,2 @@
+"""Coral reef semantic segmentation training package."""
+

coral_seg/coral_seg/dataset.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import albumentations as A
+import cv2
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+from .splits import read_ids
+from .utils import IMAGENET_MEAN, IMAGENET_STD, list_pngs, read_image, read_mask
+
+
+def build_train_transform(size: int) -> A.Compose:
+    return A.Compose(
+        [
+            A.HorizontalFlip(p=0.5),
+            A.VerticalFlip(p=0.5),
+            A.RandomRotate90(p=0.5),
+            A.Affine(
+                scale=(0.75, 1.25),
+                translate_percent=(-0.06, 0.06),
+                rotate=(-25, 25),
+                shear=(-5, 5),
+                interpolation=cv2.INTER_LINEAR,
+                mask_interpolation=cv2.INTER_NEAREST,
+                border_mode=cv2.BORDER_REFLECT_101,
+                p=0.65,
+            ),
+            A.OneOf(
+                [
+                    A.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25, p=1.0),
+                    A.HueSaturationValue(hue_shift_limit=8, sat_shift_limit=18, val_shift_limit=18, p=1.0),
+                    A.RandomGamma(gamma_limit=(75, 130), p=1.0),
+                    A.CLAHE(clip_limit=(1, 3), tile_grid_size=(8, 8), p=1.0),
+                ],
+                p=0.85,
+            ),
+            A.OneOf(
+                [
+                    A.GaussianBlur(blur_limit=(3, 5), p=1.0),
+                    A.MotionBlur(blur_limit=3, p=1.0),
+                ],
+                p=0.20,
+            ),
+            A.Resize(size, size, interpolation=cv2.INTER_LINEAR, mask_interpolation=cv2.INTER_NEAREST),
+            A.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+        ]
+    )
+
+
+def build_val_transform(size: int) -> A.Compose:
+    return A.Compose(
+        [
+            A.Resize(size, size, interpolation=cv2.INTER_LINEAR, mask_interpolation=cv2.INTER_NEAREST),
+            A.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+        ]
+    )
+
+
+class CoralSegDataset(Dataset):
+    def __init__(
+        self,
+        image_dir: str,
+        mask_dir: Optional[str] = None,
+        split_file: Optional[str] = None,
+        transform: Optional[A.Compose] = None,
+    ) -> None:
+        self.image_dir = Path(image_dir)
+        self.mask_dir = Path(mask_dir) if mask_dir else None
+        self.transform = transform
+
+        if split_file:
+            ids = read_ids(split_file)
+            self.image_paths = [self.image_dir / f"{sample_id}.png" for sample_id in ids]
+        else:
+            self.image_paths = list_pngs(self.image_dir)
+
+        if not self.image_paths:
+            raise RuntimeError(f"No PNG images found in {self.image_dir}")
+
+    def __len__(self) -> int:
+        return len(self.image_paths)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor | str]:
+        image_path = self.image_paths[idx]
+        image = read_image(image_path)
+        mask = None
+        if self.mask_dir is not None:
+            mask_path = self.mask_dir / image_path.name
+            mask = read_mask(mask_path)
+
+        if self.transform is not None:
+            if mask is None:
+                transformed = self.transform(image=image)
+                image = transformed["image"]
+            else:
+                transformed = self.transform(image=image, mask=mask)
+                image, mask = transformed["image"], transformed["mask"]
+
+        image_tensor = torch.from_numpy(image.transpose(2, 0, 1)).float()
+        sample: Dict[str, torch.Tensor | str] = {
+            "image": image_tensor,
+            "name": image_path.name,
+        }
+        if mask is not None:
+            sample["mask"] = torch.from_numpy(mask.astype(np.int64))
+        return sample
+
+
+def segmentation_collate(batch: List[Dict[str, torch.Tensor | str]]) -> Dict[str, torch.Tensor | List[str]]:
+    images = torch.stack([item["image"] for item in batch])  # type: ignore[arg-type]
+    names = [str(item["name"]) for item in batch]
+    result: Dict[str, torch.Tensor | List[str]] = {"image": images, "name": names}
+    if "mask" in batch[0]:
+        result["mask"] = torch.stack([item["mask"] for item in batch])  # type: ignore[arg-type]
+    return result
+
+
+def mask2former_collate(
+    batch: List[Dict[str, torch.Tensor | str]],
+    num_classes: int,
+) -> Dict[str, torch.Tensor | List[torch.Tensor] | List[str]]:
+    images = torch.stack([item["image"] for item in batch])  # type: ignore[arg-type]
+    names = [str(item["name"]) for item in batch]
+    result: Dict[str, torch.Tensor | List[torch.Tensor] | List[str]] = {"image": images, "name": names}
+    if "mask" not in batch[0]:
+        return result
+
+    masks = [item["mask"].long() for item in batch]  # type: ignore[union-attr]
+    mask_labels: List[torch.Tensor] = []
+    class_labels: List[torch.Tensor] = []
+    for mask in masks:
+        labels = torch.unique(mask)
+        labels = labels[(labels >= 0) & (labels < num_classes)]
+        labels = labels.sort()[0]
+        binary_masks = torch.stack([(mask == cls).float() for cls in labels], dim=0)
+        mask_labels.append(binary_masks)
+        class_labels.append(labels.long())
+
+    result["raw_mask"] = torch.stack(masks)
+    result["mask_labels"] = mask_labels
+    result["class_labels"] = class_labels
+    return result

coral_seg/coral_seg/losses.py

@@ -0,0 +1,101 @@
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DiceLoss(nn.Module):
+    def __init__(self, num_classes: int, smooth: float = 1.0, ignore_index: int = 255) -> None:
+        super().__init__()
+        self.num_classes = num_classes
+        self.smooth = smooth
+        self.ignore_index = ignore_index
+
+    def forward(self, logits: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        probs = torch.softmax(logits, dim=1)
+        valid = target != self.ignore_index
+        target_safe = target.clamp(0, self.num_classes - 1)
+        one_hot = F.one_hot(target_safe, self.num_classes).permute(0, 3, 1, 2).float()
+        valid = valid.unsqueeze(1).float()
+        probs = probs * valid
+        one_hot = one_hot * valid
+        dims = (0, 2, 3)
+        intersection = torch.sum(probs * one_hot, dims)
+        cardinality = torch.sum(probs + one_hot, dims)
+        dice = (2.0 * intersection + self.smooth) / (cardinality + self.smooth)
+        return 1.0 - dice.mean()
+
+
+def lovasz_grad(gt_sorted: torch.Tensor) -> torch.Tensor:
+    gts = gt_sorted.sum()
+    intersection = gts - gt_sorted.float().cumsum(0)
+    union = gts + (1 - gt_sorted).float().cumsum(0)
+    jaccard = 1.0 - intersection / union.clamp_min(1e-6)
+    if gt_sorted.numel() > 1:
+        jaccard[1:] = jaccard[1:] - jaccard[:-1]
+    return jaccard
+
+
+def lovasz_softmax_flat(probs: torch.Tensor, labels: torch.Tensor, num_classes: int) -> torch.Tensor:
+    losses = []
+    for cls in range(num_classes):
+        fg = (labels == cls).float()
+        if fg.sum() == 0:
+            continue
+        class_pred = probs[:, cls]
+        errors = (fg - class_pred).abs()
+        errors_sorted, perm = torch.sort(errors, descending=True)
+        fg_sorted = fg[perm]
+        losses.append(torch.dot(errors_sorted, lovasz_grad(fg_sorted)))
+    if not losses:
+        return probs.sum() * 0.0
+    return torch.stack(losses).mean()
+
+
+class LovaszSoftmaxLoss(nn.Module):
+    def __init__(self, num_classes: int, ignore_index: int = 255) -> None:
+        super().__init__()
+        self.num_classes = num_classes
+        self.ignore_index = ignore_index
+
+    def forward(self, logits: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        probs = torch.softmax(logits, dim=1).permute(0, 2, 3, 1).reshape(-1, self.num_classes)
+        labels = target.reshape(-1)
+        valid = labels != self.ignore_index
+        if valid.sum() == 0:
+            return logits.sum() * 0.0
+        return lovasz_softmax_flat(probs[valid], labels[valid], self.num_classes)
+
+
+class ComboSegLoss(nn.Module):
+    def __init__(
+        self,
+        num_classes: int,
+        ce_weight: float = 1.0,
+        dice_weight: float = 1.0,
+        lovasz_weight: float = 0.5,
+        label_smoothing: float = 0.05,
+        ignore_index: int = 255,
+    ) -> None:
+        super().__init__()
+        self.ce_weight = ce_weight
+        self.dice_weight = dice_weight
+        self.lovasz_weight = lovasz_weight
+        self.label_smoothing = label_smoothing
+        self.ignore_index = ignore_index
+        self.dice = DiceLoss(num_classes, ignore_index=ignore_index)
+        self.lovasz = LovaszSoftmaxLoss(num_classes, ignore_index=ignore_index)
+
+    def forward(self, logits: torch.Tensor, target: torch.Tensor, epoch: Optional[int] = None) -> torch.Tensor:
+        ce = F.cross_entropy(
+            logits,
+            target,
+            ignore_index=self.ignore_index,
+            label_smoothing=self.label_smoothing,
+        )
+        dice = self.dice(logits, target)
+        loss = self.ce_weight * ce + self.dice_weight * dice
+        if self.lovasz_weight > 0:
+            loss = loss + self.lovasz_weight * self.lovasz(logits, target)
+        return loss

coral_seg/coral_seg/model_convnext_fpn.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+from typing import List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.models import ConvNeXt_Large_Weights, convnext_large
+
+
+class ConvBNAct(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int = 3, dropout: float = 0.0) -> None:
+        super().__init__()
+        padding = kernel_size // 2
+        layers: List[nn.Module] = [
+            nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.GELU(),
+        ]
+        if dropout > 0:
+            layers.append(nn.Dropout2d(dropout))
+        self.block = nn.Sequential(*layers)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.block(x)
+
+
+class ConvNeXtFPN(nn.Module):
+    def __init__(
+        self,
+        num_classes: int = 4,
+        fpn_channels: int = 256,
+        pretrained: bool = True,
+        pretrained_path: str | None = None,
+        dropout: float = 0.1,
+    ) -> None:
+        super().__init__()
+        if pretrained and pretrained_path and Path(pretrained_path).is_file():
+            backbone = convnext_large(weights=None)
+            state = torch.load(pretrained_path, map_location="cpu")
+            if isinstance(state, dict) and "model" in state:
+                state = state["model"]
+            backbone.load_state_dict(state, strict=True)
+        else:
+            weights = ConvNeXt_Large_Weights.IMAGENET1K_V1 if pretrained else None
+            backbone = convnext_large(weights=weights)
+        self.features = backbone.features
+        in_channels = [192, 384, 768, 1536]
+        self.lateral = nn.ModuleList([nn.Conv2d(c, fpn_channels, 1) for c in in_channels])
+        self.smooth = nn.ModuleList([ConvBNAct(fpn_channels, fpn_channels, 3) for _ in in_channels])
+        self.decoder = nn.Sequential(
+            ConvBNAct(fpn_channels * 4, fpn_channels, 3, dropout=dropout),
+            ConvBNAct(fpn_channels, fpn_channels, 3, dropout=dropout),
+            nn.Conv2d(fpn_channels, num_classes, 1),
+        )
+
+    def forward_features(self, x: torch.Tensor) -> List[torch.Tensor]:
+        feats: List[torch.Tensor] = []
+        for idx, layer in enumerate(self.features):
+            x = layer(x)
+            if idx in (1, 3, 5, 7):
+                feats.append(x)
+        return feats
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        input_size = x.shape[-2:]
+        feats = self.forward_features(x)
+        pyramid = [lat(feat) for lat, feat in zip(self.lateral, feats)]
+        for i in range(len(pyramid) - 1, 0, -1):
+            pyramid[i - 1] = pyramid[i - 1] + F.interpolate(
+                pyramid[i],
+                size=pyramid[i - 1].shape[-2:],
+                mode="bilinear",
+                align_corners=False,
+            )
+        pyramid = [smooth(feat) for smooth, feat in zip(self.smooth, pyramid)]
+        target_size = pyramid[0].shape[-2:]
+        pyramid = [
+            feat if feat.shape[-2:] == target_size else F.interpolate(feat, size=target_size, mode="bilinear", align_corners=False)
+            for feat in pyramid
+        ]
+        logits = self.decoder(torch.cat(pyramid, dim=1))
+        return F.interpolate(logits, size=input_size, mode="bilinear", align_corners=False)

coral_seg/coral_seg/splits.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from typing import Iterable, List, Tuple
+
+import numpy as np
+
+from .utils import ensure_dir, list_pngs
+
+
+def create_split_files(
+    image_dir: str,
+    mask_dir: str,
+    split_dir: str,
+    val_ratio: float = 0.15,
+    seed: int = 2026,
+) -> Tuple[Path, Path, Path]:
+    image_paths = list_pngs(image_dir)
+    mask_dir_path = Path(mask_dir)
+    ids = []
+    for image_path in image_paths:
+        if not (mask_dir_path / image_path.name).exists():
+            raise FileNotFoundError(f"Missing mask for {image_path.name}")
+        ids.append(image_path.stem)
+
+    rng = np.random.default_rng(seed)
+    ids = np.array(ids)
+    order = rng.permutation(len(ids))
+    val_count = max(1, int(round(len(ids) * val_ratio)))
+    val_ids = sorted(ids[order[:val_count]].tolist())
+    train_ids = sorted(ids[order[val_count:]].tolist())
+    full_ids = sorted(ids.tolist())
+
+    split_path = ensure_dir(split_dir)
+    train_file = split_path / "train.txt"
+    val_file = split_path / "val.txt"
+    full_file = split_path / "train_full.txt"
+    train_file.write_text("\n".join(train_ids) + "\n", encoding="utf-8")
+    val_file.write_text("\n".join(val_ids) + "\n", encoding="utf-8")
+    full_file.write_text("\n".join(full_ids) + "\n", encoding="utf-8")
+    return train_file, val_file, full_file
+
+
+def read_ids(path: str | Path) -> List[str]:
+    p = Path(path)
+    return [line.strip() for line in p.read_text(encoding="utf-8").splitlines() if line.strip()]

coral_seg/coral_seg/utils.py

@@ -0,0 +1,140 @@
+import json
+import math
+import os
+import random
+import time
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+import numpy as np
+import torch
+import yaml
+from PIL import Image
+
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def load_config(path: str | os.PathLike[str]) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def ensure_dir(path: str | os.PathLike[str]) -> Path:
+    p = Path(path)
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.benchmark = True
+
+
+def read_image(path: str | os.PathLike[str]) -> np.ndarray:
+    return np.array(Image.open(path).convert("RGB"))
+
+
+def read_mask(path: str | os.PathLike[str]) -> np.ndarray:
+    return np.array(Image.open(path), dtype=np.uint8)
+
+
+def save_mask(path: str | os.PathLike[str], mask: np.ndarray) -> None:
+    mask = np.asarray(mask, dtype=np.uint8)
+    Image.fromarray(mask, mode="L").save(path)
+
+
+def normalize_tensor(image: np.ndarray) -> torch.Tensor:
+    image = image.astype(np.float32) / 255.0
+    mean = np.array(IMAGENET_MEAN, dtype=np.float32)
+    std = np.array(IMAGENET_STD, dtype=np.float32)
+    image = (image - mean) / std
+    return torch.from_numpy(image.transpose(2, 0, 1)).float()
+
+
+def denormalize_tensor(x: torch.Tensor) -> torch.Tensor:
+    mean = torch.tensor(IMAGENET_MEAN, device=x.device).view(1, 3, 1, 1)
+    std = torch.tensor(IMAGENET_STD, device=x.device).view(1, 3, 1, 1)
+    return x * std + mean
+
+
+class AverageMeter:
+    def __init__(self) -> None:
+        self.reset()
+
+    def reset(self) -> None:
+        self.sum = 0.0
+        self.count = 0
+
+    @property
+    def avg(self) -> float:
+        return self.sum / max(1, self.count)
+
+    def update(self, value: float, n: int = 1) -> None:
+        self.sum += float(value) * n
+        self.count += n
+
+
+def fast_hist(pred: np.ndarray, target: np.ndarray, num_classes: int, ignore_index: int = 255) -> np.ndarray:
+    pred = pred.reshape(-1)
+    target = target.reshape(-1)
+    valid = (target != ignore_index) & (target >= 0) & (target < num_classes)
+    hist = np.bincount(
+        num_classes * target[valid].astype(np.int64) + pred[valid].astype(np.int64),
+        minlength=num_classes**2,
+    )
+    return hist.reshape(num_classes, num_classes)
+
+
+def compute_iou(hist: np.ndarray) -> Tuple[np.ndarray, float]:
+    denom = hist.sum(1) + hist.sum(0) - np.diag(hist)
+    iou = np.divide(np.diag(hist), denom, out=np.full_like(denom, np.nan, dtype=np.float64), where=denom != 0)
+    return iou, float(np.nanmean(iou))
+
+
+def format_metrics(iou: np.ndarray, miou: float, class_names: Sequence[str]) -> str:
+    parts = [f"mIoU={miou:.5f}"]
+    for name, value in zip(class_names, iou):
+        parts.append(f"{name}={value:.5f}" if not np.isnan(value) else f"{name}=nan")
+    return " ".join(parts)
+
+
+def save_json(path: str | os.PathLike[str], obj: Dict[str, Any]) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, indent=2, ensure_ascii=False)
+
+
+def cosine_warmup_lambda(
+    current_step: int,
+    *,
+    total_steps: int,
+    warmup_steps: int,
+    min_factor: float = 0.01,
+) -> float:
+    if current_step < warmup_steps:
+        return float(current_step + 1) / float(max(1, warmup_steps))
+    progress = float(current_step - warmup_steps) / float(max(1, total_steps - warmup_steps))
+    cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
+    return min_factor + (1.0 - min_factor) * cosine
+
+
+def make_results_zip(results_dir: str | os.PathLike[str], zip_path: str | os.PathLike[str]) -> None:
+    results_dir = Path(results_dir)
+    zip_path = Path(zip_path)
+    ensure_dir(zip_path.parent)
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for path in sorted(results_dir.glob("*.png")):
+            zf.write(path, arcname=f"results/{path.name}")
+
+
+def list_pngs(path: str | os.PathLike[str]) -> List[Path]:
+    return sorted(Path(path).glob("*.png"))
+
+
+def timestamp() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")

coral_seg/docs/operation-guide.md

@@ -0,0 +1,575 @@
+# 完整操作指南
+
+本文档说明如何从环境部署开始，完成数据解压、预训练模型下载、模型训练、结果推理、可视化、mIoU 评估和 `results.zip` 压缩提交。
+
+## 1. 运行目录
+
+推荐从工作区根目录执行所有命令：
+
+```bash
+cd /root/autodl-tmp/coral
+```
+
+当前配置默认使用以下路径：
+
+```text
+训练图像：/root/autodl-tmp/coral/data_fresh/train_bsdtar/train/image
+训练标签：/root/autodl-tmp/coral/data_fresh/train_bsdtar/train/label
+测试图像：/root/autodl-tmp/coral/data_fresh/test_raw/PrecisionLabel800/images
+工程目录：/root/autodl-tmp/coral/coral_seg
+```
+
+## 2. 环境部署
+
+本项目没有单独新建 conda 环境，直接使用当前默认 Python 环境。
+
+检查当前环境：
+
+```bash
+which python
+python -V
+python -c "import torch; print(torch.__version__, torch.cuda.is_available())"
+```
+
+当前已验证版本：
+
+```text
+Python 3.12.3
+PyTorch 2.3.0+cu121
+torchvision 0.18.0+cu121
+transformers 4.46.3
+timm 1.0.27
+albumentations 2.0.8
+opencv-python-headless 4.13.0.92
+```
+
+如果需要重新安装依赖：
+
+```bash
+python -m pip install -U \
+  transformers==4.46.3 \
+  timm==1.0.27 \
+  albumentations==2.0.8 \
+  opencv-python-headless==4.13.0.92 \
+  safetensors \
+  accelerate \
+  PyYAML \
+  huggingface-hub
+```
+
+不要随意升级 `torch` 和 `torchvision`，当前训练代码已经按现有版本验证通过。
+
+## 3. 数据解压
+
+如果 `data_fresh/` 已经存在且检查正常，可以跳过本节。
+
+外层数据包：
+
+```text
+/root/autodl-tmp/比赛data.zip
+```
+
+解压外层 zip：
+
+```bash
+mkdir -p extracted_zip
+unzip -q -o '比赛data.zip' -d extracted_zip
+```
+
+外层解压后包含：
+
+```text
+比赛data/train.rar
+比赛data/test.zip
+```
+
+训练集建议使用 `bsdtar` 解压。旧版 `7z` 对该 RAR5 压缩方式可能报 `Unsupported Method`。
+
+```bash
+mkdir -p data_fresh/train_bsdtar
+bsdtar -xf 'extracted_zip/比赛data/train.rar' -C data_fresh/train_bsdtar
+```
+
+测试集解压：
+
+```bash
+mkdir -p data_fresh/test_raw
+unzip -q -o 'extracted_zip/比赛data/test.zip' -d data_fresh/test_raw
+```
+
+清理旧数据和临时目录：
+
+```bash
+rm -rf data data_fresh/train_raw extracted_zip
+```
+
+## 4. 检查数据
+
+执行：
+
+```bash
+python coral_seg/tools/check_data.py --config coral_seg/configs/final_dual.yaml
+```
+
+正常输出应包含：
+
+```text
+train_images 3000 0000.png 2999.png
+train_masks 3000 0000.png 2999.png
+test_images 800 image_0001.png image_0800.png
+mask values: [0, 1, 2, 3]
+bad masks: 0 []
+```
+
+如果 `bad masks` 不为 0，说明训练标签像素值异常，不应继续训练。
+
+## 5. 预训练模型部署和下载
+
+本方案需要两类预训练模型，均通过配置文件显式指定路径。
+
+```text
+Mask2Former-Swin-B：facebook/mask2former-swin-base-ade-semantic
+ConvNeXt-L：torchvision convnext_large ImageNet-1K 权重
+```
+
+配置位置：
+
+```text
+coral_seg/configs/final_dual.yaml
+```
+
+对应字段：
+
+```text
+mask2former.pretrained_name: facebook/mask2former-swin-base-ade-semantic
+mask2former.pretrained_dir:  /root/autodl-tmp/coral/coral_seg/pretrained/mask2former-swin-base-ade-semantic
+convnext.pretrained_path:    /root/autodl-tmp/coral/coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+### 5.1 在线下载
+
+如果机器可以访问 HuggingFace 和 PyTorch 权重源，直接执行：
+
+```bash
+python coral_seg/tools/download_pretrained.py --config coral_seg/configs/final_dual.yaml
+```
+
+该脚本会完成两件事：
+
+```text
+1. 下载 Mask2Former-Swin-B 到 coral_seg/pretrained/mask2former-swin-base-ade-semantic/
+2. 下载 ConvNeXt-L 的 torchvision 权重，并复制到 coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+下载完成后，工程内应存在：
+
+```text
+coral_seg/pretrained/
+├── convnext_large-ea097f82.pth
+└── mask2former-swin-base-ade-semantic/
+    ├── config.json
+    ├── preprocessor_config.json
+    ├── model.safetensors
+    └── pytorch_model.bin
+```
+
+`model.safetensors` 和 `pytorch_model.bin` 至少保留一个即可；当前目录同时保留两者，便于不同版本 `transformers` 加载。
+
+### 5.2 离线部署
+
+如果复现环境不能联网，需要提前把预训练模型放到以下位置。
+
+Mask2Former 目录：
+
+```text
+/root/autodl-tmp/coral/coral_seg/pretrained/mask2former-swin-base-ade-semantic/
+```
+
+该目录至少需要包含：
+
+```text
+config.json
+preprocessor_config.json
+model.safetensors 或 pytorch_model.bin
+```
+
+ConvNeXt-L 权重文件：
+
+```text
+/root/autodl-tmp/coral/coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+如果当前机器已经有 torchvision 缓存，可以复制到工程目录：
+
+```bash
+mkdir -p coral_seg/pretrained
+cp /root/.cache/torch/hub/checkpoints/convnext_large-ea097f82.pth \
+  coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+训练代码会优先读取 `convnext.pretrained_path`。只要该文件存在，就不会依赖 `/root/.cache/torch` 中的缓存。
+
+### 5.3 完整性检查
+
+执行以下命令检查预训练模型文件是否齐全：
+
+```bash
+python - <<'PY_CHECK'
+from pathlib import Path
+
+root = Path('coral_seg/pretrained')
+mask2former = root / 'mask2former-swin-base-ade-semantic'
+convnext = root / 'convnext_large-ea097f82.pth'
+
+required = [
+    mask2former / 'config.json',
+    mask2former / 'preprocessor_config.json',
+    convnext,
+]
+missing = [str(p) for p in required if not p.is_file()]
+has_weight = (mask2former / 'model.safetensors').is_file() or (mask2former / 'pytorch_model.bin').is_file()
+if not has_weight:
+    missing.append(str(mask2former / 'model.safetensors 或 pytorch_model.bin'))
+
+print('missing:', missing)
+print('mask2former_dir:', mask2former.resolve())
+print('convnext_weight:', convnext.resolve(), convnext.stat().st_size if convnext.is_file() else 0)
+PY_CHECK
+```
+
+正常情况下：
+
+```text
+missing: []
+```
+
+### 5.4 加载说明
+
+ConvNeXt 分支：
+
+```text
+coral_seg/model_convnext_fpn.py 会优先读取 convnext.pretrained_path
+如果该文件不存在，才会退回到 torchvision 自动下载或缓存加载
+```
+
+Mask2Former 分支：
+
+```text
+train_mask2former.py 会从 mask2former.pretrained_dir 加载本地目录
+分类头从 ADE20K 的 150 类改为本任务的 4 类，因此分类头重新初始化是正常现象
+```
+
+常见日志：
+
+```text
+class_predictor shape mismatch
+```
+
+这是正常现象，不是权重损坏。
+
+如果在线下载时出现网络超时，可以改用离线部署方式，只要上述文件清单完整即可继续训练。
+
+## 6. 生成训练和验证划分
+
+执行：
+
+```bash
+python coral_seg/tools/create_splits.py --config coral_seg/configs/final_dual.yaml
+```
+
+生成：
+
+```text
+coral_seg/splits/train.txt
+coral_seg/splits/val.txt
+coral_seg/splits/train_full.txt
+```
+
+默认划分：
+
+```text
+85% 训练集
+15% 验证集
+seed = 2026
+```
+
+## 7. 训练 ConvNeXt-L-FPN
+
+建议先训练 ConvNeXt 分支，因为它更稳定、速度更快。
+
+```bash
+mkdir -p coral_seg/logs
+
+python coral_seg/tools/train_convnext.py \
+  --config coral_seg/configs/final_dual.yaml \
+  2>&1 | tee coral_seg/logs/convnext_train.log
+```
+
+主要配置：
+
+```text
+输入尺寸：512
+batch size：4
+epoch：120
+优化器：AdamW
+学习率：6e-5
+损失函数：CE + Dice + Lovasz
+label smoothing：0.05
+```
+
+训练产物：
+
+```text
+coral_seg/work_dirs/convnext_l_fpn/best.pth
+coral_seg/work_dirs/convnext_l_fpn/latest.pth
+```
+
+查看日志：
+
+```bash
+tail -f coral_seg/logs/convnext_train.log
+```
+
+查看验证集 mIoU：
+
+```bash
+grep "convnext val" coral_seg/logs/convnext_train.log
+```
+
+## 8. 训练 Mask2Former-Swin-B
+
+ConvNeXt 训练完成后，训练 Mask2Former：
+
+```bash
+python coral_seg/tools/train_mask2former.py \
+  --config coral_seg/configs/final_dual.yaml \
+  2>&1 | tee coral_seg/logs/mask2former_train.log
+```
+
+主要配置：
+
+```text
+输入尺寸：384
+batch size：2
+epoch：80
+优化器：AdamW
+学习率：3e-5
+预训练权重：facebook/mask2former-swin-base-ade-semantic
+```
+
+训练产物：
+
+```text
+coral_seg/work_dirs/mask2former_swin_b/best.pth
+coral_seg/work_dirs/mask2former_swin_b/latest.pth
+coral_seg/work_dirs/mask2former_swin_b/best_hf/
+```
+
+查看日志：
+
+```bash
+tail -f coral_seg/logs/mask2former_train.log
+```
+
+查看验证集 mIoU：
+
+```bash
+grep "mask2former val" coral_seg/logs/mask2former_train.log
+```
+
+常见日志说明：
+
+```text
+class_predictor shape mismatch
+```
+
+这是正常现象。ADE20K 预训练模型是 150 类，本任务是 4 类，分类头需要重新初始化。
+
+```text
+Gradient checkpointing is not supported
+```
+
+这是正常现象。本地 transformers 的 Mask2Former 类不支持梯度检查点，代码会自动跳过。
+
+## 9. 查看 GPU 状态
+
+```bash
+nvidia-smi
+```
+
+持续刷新：
+
+```bash
+watch -n 2 nvidia-smi
+```
+
+## 10. 中断后继续训练
+
+ConvNeXt 继续训练：
+
+```bash
+python coral_seg/tools/train_convnext.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --resume coral_seg/work_dirs/convnext_l_fpn/latest.pth
+```
+
+Mask2Former 继续训练：
+
+```bash
+python coral_seg/tools/train_mask2former.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --resume coral_seg/work_dirs/mask2former_swin_b/latest.pth
+```
+
+## 11. 验证集融合 mIoU
+
+两个模型都训练完成后，计算验证集双模型融合 mIoU：
+
+```bash
+python coral_seg/tools/eval_ensemble_val.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --convnext-checkpoint coral_seg/work_dirs/convnext_l_fpn/best.pth \
+  --mask2former-checkpoint coral_seg/work_dirs/mask2former_swin_b/best_hf
+```
+
+## 12. 测试集推理
+
+双模型融合推理：
+
+```bash
+python coral_seg/tools/infer_ensemble.py \
+  --config coral_seg/configs/final_dual.yaml \
+  --convnext-checkpoint coral_seg/work_dirs/convnext_l_fpn/best.pth \
+  --mask2former-checkpoint coral_seg/work_dirs/mask2former_swin_b/best_hf
+```
+
+推理输出：
+
+```text
+coral_seg/submissions/results/
+coral_seg/submissions/results.zip
+```
+
+`results/` 中应包含 800 张单通道 PNG：
+
+```text
+image_0001.png
+image_0002.png
+...
+image_0800.png
+```
+
+每张 PNG 的像素值只能是：
+
+```text
+0, 1, 2, 3
+```
+
+## 13. 检查并压缩 results
+
+推理脚本会自动压缩 `results.zip`。如果需要手动检查：
+
+```bash
+python - <<'PY_CHECK'
+import zipfile
+from pathlib import Path
+from PIL import Image
+import numpy as np
+
+zip_path = Path('coral_seg/submissions/results.zip')
+with zipfile.ZipFile(zip_path) as zf:
+    names = zf.namelist()
+    print('num files:', len(names))
+    print('first:', names[:3])
+    print('last:', names[-3:])
+
+values = set()
+for p in sorted(Path('coral_seg/submissions/results').glob('*.png')):
+    arr = np.array(Image.open(p))
+    values |= set(np.unique(arr).tolist())
+print('values:', sorted(values))
+PY_CHECK
+```
+
+正常结果：
+
+```text
+num files: 800
+first: ['results/image_0001.png', ...]
+values: [0, 1, 2, 3]
+```
+
+如果需要手动重新压缩：
+
+```bash
+cd coral_seg/submissions
+zip -r results.zip results
+cd /root/autodl-tmp/coral
+```
+
+压缩包内部结构必须是：
+
+```text
+results.zip
+└── results/
+    ├── image_0001.png
+    ├── image_0002.png
+    ├── ...
+    └── image_0800.png
+```
+
+## 14. 生成可视化结果
+
+```bash
+python coral_seg/tools/visualize_results.py \
+  --image-dir data_fresh/test_raw/PrecisionLabel800/images \
+  --pred-dir coral_seg/submissions/results \
+  --out-dir coral_seg/vis_results \
+  --num 24
+```
+
+输出目录：
+
+```text
+coral_seg/vis_results/
+```
+
+每张可视化图包含：
+
+```text
+原图
+预测彩色 mask
+预测叠加图
+```
+
+## 15. 本地 test mIoU
+
+只有当 `data_fresh/test_raw/PrecisionLabel800/mask` 确认为官方测试集真值时，下面的 test mIoU 才有意义。
+
+当前识别到该目录是 RGB 彩色 mask，颜色映射为：
+
+```text
+(0, 0, 0)       -> 0 背景
+(240, 110, 170) -> 1 活珊瑚
+(240, 171, 203) -> 2 死珊瑚
+(0, 162, 232)   -> 3 白化珊瑚
+```
+
+计算命令：
+
+```bash
+python coral_seg/tools/eval_predictions.py \
+  --pred-dir coral_seg/submissions/results \
+  --gt-dir data_fresh/test_raw/PrecisionLabel800/mask \
+  --color-map '0,0,0:0;240,110,170:1;240,171,203:2;0,162,232:3'
+```
+
+如果该 `mask` 目录不是官方真值，而只是参考或占位 mask，则最终测试集成绩以竞赛平台为准。
+
+## 16. 最终提交文件
+
+最终提交文件位置：
+
+```text
+/root/autodl-tmp/coral/coral_seg/submissions/results.zip
+```

coral_seg/docs/technical-report.md

@@ -0,0 +1,566 @@
+# 方法与技术细节说明
+
+本文档说明本项目解决水下珊瑚语义分割任务的完整技术方案，包括任务分析、模型设计、训练策略、损失函数、数据增强、融合推理、mIoU 计算和复现设计。
+
+## 1. 任务定义
+
+输入为 `256x256` RGB 水下图像，输出为同尺寸单通道语义分割图。
+
+类别定义：
+
+```text
+0 背景
+1 活珊瑚
+2 死珊瑚
+3 白化珊瑚
+```
+
+评价指标为 mIoU。
+
+比赛限制：
+
+```text
+只允许使用官方训练集
+测试集只允许用于推理
+不得使用伪标签、自训练或测试集分布统计更新
+预训练模型必须是 2026-01-01 前公开发布的开源模型
+最终复现要求在 A30 单卡 24G 上训练和推理总时间不超过 24 小时
+```
+
+## 2. 数据难点
+
+水下珊瑚图像相比普通自然图像有明显差异：
+
+```text
+光照不均
+颜色偏移
+水体浑浊
+悬浮颗粒干扰
+珊瑚边界不规则
+活珊瑚、死珊瑚、白化珊瑚外观相似
+标签存在噪声
+```
+
+因此，模型需要同时利用：
+
+```text
+局部纹理
+边界形态
+多尺度上下文
+全局语义信息
+```
+
+单纯依赖颜色容易失败，尤其在水下颜色失真严重时。
+
+## 3. 总体方案
+
+最终采用双模型融合：
+
+```text
+Mask2Former-Swin-B + ConvNeXt-L-FPN
+```
+
+职责划分：
+
+```text
+Mask2Former-Swin-B：负责复杂区域、全局上下文和 mask 级建模
+ConvNeXt-L-FPN：负责局部纹理、边界细节和卷积稳定性
+```
+
+融合方式：
+
+```text
+final_prob = 0.55 * prob_mask2former + 0.45 * prob_convnext
+prediction = argmax(final_prob)
+```
+
+选择异构融合的原因：
+
+```text
+两类模型错误模式不同
+Transformer 更擅长全局关系
+卷积模型更擅长局部纹理和边界
+概率融合可以降低单模型偶然错误
+```
+
+## 4. ConvNeXt-L-FPN 分支
+
+### 4.1 ConvNeXt-L 骨干
+
+ConvNeXt 是现代卷积网络，吸收了 Transformer 时代的一些结构设计，例如：
+
+```text
+大卷积核深度卷积
+更合理的 stage 设计
+GELU 激活
+LayerNorm 风格结构
+倒瓶颈结构
+```
+
+本项目使用 torchvision 的 `convnext_large`，并加载 ImageNet-1K 预训练权重。
+
+优势：
+
+```text
+原生 torchvision 支持，环境稳定
+卷积归纳偏置强，适合小数据和纹理任务
+局部边界表达能力好
+训练速度可控
+```
+
+### 4.2 FPN 解码器
+
+ConvNeXt-L 输出四个尺度特征：
+
+```text
+192, 384, 768, 1536 channels
+```
+
+FPN 解码流程：
+
+```text
+1. 每层特征用 1x1 卷积投影到 256 通道
+2. 高层特征逐级上采样并与低层相加
+3. 每层用 3x3 卷积平滑
+4. 所有尺度上采样到同一分辨率
+5. 拼接后输出 4 类 logits
+```
+
+FPN 的作用：
+
+```text
+高层特征提供语义
+低层特征提供边界
+多尺度融合提升小目标和复杂区域分割效果
+```
+
+### 4.3 ConvNeXt 训练配置
+
+```text
+输入尺寸：512
+batch size：4
+epoch：120
+优化器：AdamW
+基础学习率：6e-5
+backbone 学习率：基础学习率的 0.25
+weight decay：0.01
+学习率策略：warmup + cosine decay
+混合精度：开启
+```
+
+骨干网络使用更低学习率，是为了保护预训练特征，降低小数据噪声标签导致的过拟合风险。
+
+## 5. Mask2Former-Swin-B 分支
+
+### 5.1 Mask2Former 思想
+
+Mask2Former 将分割任务建模为 mask classification。
+
+普通语义分割直接输出每个像素的类别；Mask2Former 则预测一组 query，每个 query 包含：
+
+```text
+类别概率
+对应的二值 mask
+```
+
+最终语义分割通过：
+
+```text
+类别概率 x mask 概率
+```
+
+组合成每个类别的像素概率图。
+
+这种方式对复杂、不规则区域更友好，适合珊瑚这类边界复杂的对象。
+
+### 5.2 Swin Transformer 骨干
+
+Swin Transformer 使用窗口注意力机制：
+
+```text
+局部窗口 self-attention 降低计算量
+shifted window 实现跨窗口信息交互
+分层结构输出多尺度特征
+```
+
+它同时具备 Transformer 的上下文建模能力和类似 CNN 的层级特征结构。
+
+### 5.3 预训练模型
+
+Mask2Former 分支使用：
+
+```text
+facebook/mask2former-swin-base-ade-semantic
+```
+
+该模型是 ADE20K 语义分割预训练模型。ADE20K 为 150 类，本任务为 4 类，因此加载时分类头会重新初始化，这是正常现象。
+
+ConvNeXt 分支使用：
+
+```text
+torchvision convnext_large ImageNet-1K 权重
+```
+
+本地部署路径由配置文件固定：
+
+```text
+mask2former.pretrained_dir = /root/autodl-tmp/coral/coral_seg/pretrained/mask2former-swin-base-ade-semantic
+convnext.pretrained_path = /root/autodl-tmp/coral/coral_seg/pretrained/convnext_large-ea097f82.pth
+```
+
+这样复现时不依赖临时下载缓存；联网环境可以运行 `tools/download_pretrained.py` 下载，离线环境只需要提前放入对应文件。
+
+### 5.4 标签格式转换
+
+原始标签格式：
+
+```text
+H x W，像素值为 0/1/2/3
+```
+
+Mask2Former 训练需要转换为：
+
+```text
+class_labels：当前图像中出现过的类别编号
+mask_labels：每个类别对应一个二值 mask
+```
+
+例如图像中出现类别 0、1、3，则：
+
+```text
+class_labels = [0, 1, 3]
+mask_labels.shape = [3, H, W]
+```
+
+## 6. 数据增强
+
+水下图像受光照、水体和成像条件影响明显，因此增强策略重点覆盖几何变化和颜色变化。
+
+使用增强：
+
+```text
+HorizontalFlip
+VerticalFlip
+RandomRotate90
+Affine scale/translate/rotate/shear
+RandomBrightnessContrast
+HueSaturationValue
+RandomGamma
+CLAHE
+GaussianBlur
+MotionBlur
+Resize
+Normalize
+```
+
+几何增强模拟：
+
+```text
+拍摄方向变化
+视角变化
+尺度变化
+轻微形变
+```
+
+颜色增强模拟：
+
+```text
+水下光照变化
+色偏
+对比度变化
+相机白平衡差异
+```
+
+模糊增强模拟：
+
+```text
+水体浑浊
+运动模糊
+散射导致的细节损失
+```
+
+## 7. 损失函数
+
+ConvNeXt 分支使用组合损失：
+
+```text
+Loss = CE + Dice + 0.5 * Lovasz
+```
+
+### 7.1 交叉熵损失
+
+交叉熵用于像素级分类监督：
+
+```text
+CE = -log P(correct_class)
+```
+
+优点是稳定、收敛快。
+
+### 7.2 Dice Loss
+
+Dice 衡量预测区域与真实区域的重叠程度：
+
+```text
+Dice = 2 * intersection / (prediction + target)
+```
+
+适合类别不均衡和小区域分割。
+
+### 7.3 Lovasz Loss
+
+Lovasz Softmax 是 IoU 的可优化近似，更贴近比赛 mIoU 指标。
+
+作用：
+
+```text
+优化目标更接近 mIoU
+提升区域交并比表现
+```
+
+### 7.4 Label Smoothing
+
+使用：
+
+```text
+label_smoothing = 0.05
+```
+
+作用：
+
+```text
+降低模型对噪声标签的过度自信
+提高泛化能力
+缓解标注误差
+```
+
+Mask2Former 分支使用模型内部的分类、mask 和 dice 损失组合。
+
+## 8. 学习率策略
+
+两个模型均使用：
+
+```text
+warmup + cosine decay
+```
+
+warmup 作用：
+
+```text
+避免训练初期学习率过大破坏预训练权重
+降低 loss 震荡
+提升训练稳定性
+```
+
+cosine decay 作用：
+
+```text
+后期平滑降低学习率
+帮助模型收敛到更稳定的局部最优
+```
+
+## 9. 噪声标签处理
+
+当前方案通过以下方式降低噪声标签影响：
+
+```text
+使用强预训练模型
+使用 label smoothing
+使用 Dice 和 Lovasz 关注区域级一致性
+强数据增强提升泛化
+保存验证集 best checkpoint
+双模型融合降低单模型噪声敏感性
+```
+
+没有使用测试集伪标签、自训练或测试集分布统计，符合比赛规则。
+
+## 10. 融合推理
+
+两个模型分别输出每个类别的概率图：
+
+```text
+prob_convnext: [4, H, W]
+prob_mask2former: [4, H, W]
+```
+
+融合：
+
+```text
+prob = 0.45 * prob_convnext + 0.55 * prob_mask2former
+pred = argmax(prob)
+```
+
+使用概率融合而不是硬投票的原因：
+
+```text
+可以保留模型置信度
+对边界和混淆区域更平滑
+高置信模型可以纠正低置信模型
+```
+
+## 11. TTA 推理
+
+当前使用：
+
+```text
+原图
+水平翻转
+```
+
+流程：
+
+```text
+1. 原图推理得到概率
+2. 水平翻转图像推理
+3. 将翻转预测翻回原方向
+4. 对概率求平均
+```
+
+TTA 可以降低方向相关误差，提升预测稳定性。
+
+## 12. mIoU 计算原理
+
+对每个类别 c：
+
+```text
+TP_c：预测为 c 且真值为 c 的像素数
+FP_c：预测为 c 但真值不是 c 的像素数
+FN_c：真值为 c 但预测不是 c 的像素数
+```
+
+类别 IoU：
+
+```text
+IoU_c = TP_c / (TP_c + FP_c + FN_c)
+```
+
+最终：
+
+```text
+mIoU = mean(IoU_0, IoU_1, IoU_2, IoU_3)
+```
+
+这里的“区域”是同一类别的像素集合，不是实例框、连通块或单独目标实例。
+
+## 13. 本地 test mask 说明
+
+`data_fresh/test_raw/PrecisionLabel800/mask` 是 RGB 彩色图，不是标准单通道标签。
+
+统计到的颜色：
+
+```text
+(0, 0, 0)
+(240, 110, 170)
+(240, 171, 203)
+(0, 162, 232)
+```
+
+当前最合理颜色映射：
+
+```text
+(0, 0, 0)       -> 0 背景
+(240, 110, 170) -> 1 活珊瑚
+(240, 171, 203) -> 2 死珊瑚
+(0, 162, 232)   -> 3 白化珊瑚
+```
+
+如果该目录不是官方真值，则该结果不能代表平台成绩。
+
+## 14. 复现性设计
+
+为满足 A30 单卡 24G、24 小时内复现，方案做了以下取舍：
+
+```text
+不使用 5-fold
+不使用第三个大模型
+不使用超大输入尺寸
+不使用测试集伪标签
+不使用测试集统计更新
+固定 seed
+保存固定 train/val split
+保存 best/latest checkpoint
+提供完整训练、推理和打包脚本
+```
+
+推荐复现流程：
+
+```text
+1. 检查数据
+2. 下载预训练权重
+3. 训练 ConvNeXt-L-FPN
+4. 训练 Mask2Former-Swin-B
+5. 验证集融合评估
+6. 测试集融合推理
+7. 生成 results.zip
+```
+
+## 15. 代码模块说明
+
+```text
+coral_seg/coral_seg/dataset.py
+```
+
+负责图像读取、标签读取、数据增强和 Mask2Former 标签格式转换。
+
+```text
+coral_seg/coral_seg/model_convnext_fpn.py
+```
+
+负责 ConvNeXt-L 骨��和 FPN 解码器。
+
+```text
+coral_seg/coral_seg/losses.py
+```
+
+负责 CE、Dice、Lovasz 和组合损失。
+
+```text
+coral_seg/tools/train_convnext.py
+```
+
+负责 ConvNeXt 分支训练、验证和 checkpoint 保存。
+
+```text
+coral_seg/tools/train_mask2former.py
+```
+
+负责 Mask2Former 分支训练、验证和 HuggingFace 格式权重保存。
+
+```text
+coral_seg/tools/infer_ensemble.py
+```
+
+负责双模型 TTA 推理、概率融合、PNG 输出和 `results.zip` 生成。
+
+```text
+coral_seg/tools/eval_ensemble_val.py
+```
+
+负责验证集双模型融合 mIoU 计算。
+
+```text
+coral_seg/tools/eval_predictions.py
+```
+
+负责已有预测和标签目录之间的 mIoU 计算，支持 RGB 标签颜色映射。
+
+```text
+coral_seg/tools/visualize_results.py
+```
+
+负责预测结果彩色化和叠加可视化。
+
+## 16. 可提升方向
+
+如果后续还有时间，可以尝试：
+
+```text
+调整融合权重，例如 0.50/0.50 或 0.60/0.40
+对白化珊瑚增加类别权重
+增加轻量多尺度 TTA
+人工清洗明显错误标签
+最终阶段使用 train_full.txt 全量复训
+后处理去除极小孤立区域
+```
+
+正式复现阶段应优先保持当前稳定配置，避免引入不可控变量。

coral_seg/pretrained/convnext_large-ea097f82.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea097f822cdb2cab40905cec3949f4bdf6d6bf1d546c3ec5e43f0b1c6275e144
+size 791189585

coral_seg/pretrained/mask2former-swin-base-ade-semantic/.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

coral_seg/pretrained/mask2former-swin-base-ade-semantic/config.json

@@ -0,0 +1,454 @@
+{
+  "_commit_hash": null,
+  "activation_function": "relu",
+  "architectures": [
+    "Mask2FormerForUniversalSegmentation"
+  ],
+  "backbone_config": {
+    "_name_or_path": "",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attention_probs_dropout_prob": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "depths": [
+      2,
+      2,
+      18,
+      2
+    ],
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "drop_path_rate": 0.3,
+    "early_stopping": false,
+    "embed_dim": 128,
+    "encoder_no_repeat_ngram_size": 0,
+    "encoder_stride": 32,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 1024,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_size": 224,
+    "initializer_range": 0.02,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "mlp_ratio": 4.0,
+    "model_type": "swin",
+    "no_repeat_ngram_size": 0,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_channels": 3,
+    "num_heads": [
+      4,
+      8,
+      16,
+      32
+    ],
+    "num_layers": 4,
+    "num_return_sequences": 1,
+    "out_features": [
+      "stage1",
+      "stage2",
+      "stage3",
+      "stage4"
+    ],
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "patch_size": 4,
+    "path_norm": true,
+    "prefix": null,
+    "problem_type": null,
+    "pruned_heads": {},
+    "qkv_bias": true,
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "stage_names": [
+      "stem",
+      "stage1",
+      "stage2",
+      "stage3",
+      "stage4"
+    ],
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.26.0.dev0",
+    "typical_p": 1.0,
+    "use_absolute_embeddings": false,
+    "use_bfloat16": false,
+    "window_size": 12
+  },
+  "class_weight": 2.0,
+  "common_stride": 4,
+  "decoder_layers": 10,
+  "dice_weight": 5.0,
+  "dim_feedforward": 2048,
+  "dropout": 0.0,
+  "encoder_feedforward_dim": 1024,
+  "encoder_layers": 6,
+  "enforce_input_proj": false,
+  "enforce_input_projection": false,
+  "feature_size": 256,
+  "feature_strides": [
+    4,
+    8,
+    16,
+    32
+  ],
+  "hidden_dim": 256,
+  "id2label": {
+    "0": "wall",
+    "1": "building",
+    "2": "sky",
+    "3": "floor",
+    "4": "tree",
+    "5": "ceiling",
+    "6": "road",
+    "7": "bed ",
+    "8": "windowpane",
+    "9": "grass",
+    "10": "cabinet",
+    "11": "sidewalk",
+    "12": "person",
+    "13": "earth",
+    "14": "door",
+    "15": "table",
+    "16": "mountain",
+    "17": "plant",
+    "18": "curtain",
+    "19": "chair",
+    "20": "car",
+    "21": "water",
+    "22": "painting",
+    "23": "sofa",
+    "24": "shelf",
+    "25": "house",
+    "26": "sea",
+    "27": "mirror",
+    "28": "rug",
+    "29": "field",
+    "30": "armchair",
+    "31": "seat",
+    "32": "fence",
+    "33": "desk",
+    "34": "rock",
+    "35": "wardrobe",
+    "36": "lamp",
+    "37": "bathtub",
+    "38": "railing",
+    "39": "cushion",
+    "40": "base",
+    "41": "box",
+    "42": "column",
+    "43": "signboard",
+    "44": "chest of drawers",
+    "45": "counter",
+    "46": "sand",
+    "47": "sink",
+    "48": "skyscraper",
+    "49": "fireplace",
+    "50": "refrigerator",
+    "51": "grandstand",
+    "52": "path",
+    "53": "stairs",
+    "54": "runway",
+    "55": "case",
+    "56": "pool table",
+    "57": "pillow",
+    "58": "screen door",
+    "59": "stairway",
+    "60": "river",
+    "61": "bridge",
+    "62": "bookcase",
+    "63": "blind",
+    "64": "coffee table",
+    "65": "toilet",
+    "66": "flower",
+    "67": "book",
+    "68": "hill",
+    "69": "bench",
+    "70": "countertop",
+    "71": "stove",
+    "72": "palm",
+    "73": "kitchen island",
+    "74": "computer",
+    "75": "swivel chair",
+    "76": "boat",
+    "77": "bar",
+    "78": "arcade machine",
+    "79": "hovel",
+    "80": "bus",
+    "81": "towel",
+    "82": "light",
+    "83": "truck",
+    "84": "tower",
+    "85": "chandelier",
+    "86": "awning",
+    "87": "streetlight",
+    "88": "booth",
+    "89": "television receiver",
+    "90": "airplane",
+    "91": "dirt track",
+    "92": "apparel",
+    "93": "pole",
+    "94": "land",
+    "95": "bannister",
+    "96": "escalator",
+    "97": "ottoman",
+    "98": "bottle",
+    "99": "buffet",
+    "100": "poster",
+    "101": "stage",
+    "102": "van",
+    "103": "ship",
+    "104": "fountain",
+    "105": "conveyer belt",
+    "106": "canopy",
+    "107": "washer",
+    "108": "plaything",
+    "109": "swimming pool",
+    "110": "stool",
+    "111": "barrel",
+    "112": "basket",
+    "113": "waterfall",
+    "114": "tent",
+    "115": "bag",
+    "116": "minibike",
+    "117": "cradle",
+    "118": "oven",
+    "119": "ball",
+    "120": "food",
+    "121": "step",
+    "122": "tank",
+    "123": "trade name",
+    "124": "microwave",
+    "125": "pot",
+    "126": "animal",
+    "127": "bicycle",
+    "128": "lake",
+    "129": "dishwasher",
+    "130": "screen",
+    "131": "blanket",
+    "132": "sculpture",
+    "133": "hood",
+    "134": "sconce",
+    "135": "vase",
+    "136": "traffic light",
+    "137": "tray",
+    "138": "ashcan",
+    "139": "fan",
+    "140": "pier",
+    "141": "crt screen",
+    "142": "plate",
+    "143": "monitor",
+    "144": "bulletin board",
+    "145": "shower",
+    "146": "radiator",
+    "147": "glass",
+    "148": "clock",
+    "149": "flag"
+  },
+  "ignore_value": 255,
+  "importance_sample_ratio": 0.75,
+  "init_std": 0.02,
+  "init_xavier_std": 1.0,
+  "label2id": {
+    "airplane": 90,
+    "animal": 126,
+    "apparel": 92,
+    "arcade machine": 78,
+    "armchair": 30,
+    "ashcan": 138,
+    "awning": 86,
+    "bag": 115,
+    "ball": 119,
+    "bannister": 95,
+    "bar": 77,
+    "barrel": 111,
+    "base": 40,
+    "basket": 112,
+    "bathtub": 37,
+    "bed ": 7,
+    "bench": 69,
+    "bicycle": 127,
+    "blanket": 131,
+    "blind": 63,
+    "boat": 76,
+    "book": 67,
+    "bookcase": 62,
+    "booth": 88,
+    "bottle": 98,
+    "box": 41,
+    "bridge": 61,
+    "buffet": 99,
+    "building": 1,
+    "bulletin board": 144,
+    "bus": 80,
+    "cabinet": 10,
+    "canopy": 106,
+    "car": 20,
+    "case": 55,
+    "ceiling": 5,
+    "chair": 19,
+    "chandelier": 85,
+    "chest of drawers": 44,
+    "clock": 148,
+    "coffee table": 64,
+    "column": 42,
+    "computer": 74,
+    "conveyer belt": 105,
+    "counter": 45,
+    "countertop": 70,
+    "cradle": 117,
+    "crt screen": 141,
+    "curtain": 18,
+    "cushion": 39,
+    "desk": 33,
+    "dirt track": 91,
+    "dishwasher": 129,
+    "door": 14,
+    "earth": 13,
+    "escalator": 96,
+    "fan": 139,
+    "fence": 32,
+    "field": 29,
+    "fireplace": 49,
+    "flag": 149,
+    "floor": 3,
+    "flower": 66,
+    "food": 120,
+    "fountain": 104,
+    "glass": 147,
+    "grandstand": 51,
+    "grass": 9,
+    "hill": 68,
+    "hood": 133,
+    "house": 25,
+    "hovel": 79,
+    "kitchen island": 73,
+    "lake": 128,
+    "lamp": 36,
+    "land": 94,
+    "light": 82,
+    "microwave": 124,
+    "minibike": 116,
+    "mirror": 27,
+    "monitor": 143,
+    "mountain": 16,
+    "ottoman": 97,
+    "oven": 118,
+    "painting": 22,
+    "palm": 72,
+    "path": 52,
+    "person": 12,
+    "pier": 140,
+    "pillow": 57,
+    "plant": 17,
+    "plate": 142,
+    "plaything": 108,
+    "pole": 93,
+    "pool table": 56,
+    "poster": 100,
+    "pot": 125,
+    "radiator": 146,
+    "railing": 38,
+    "refrigerator": 50,
+    "river": 60,
+    "road": 6,
+    "rock": 34,
+    "rug": 28,
+    "runway": 54,
+    "sand": 46,
+    "sconce": 134,
+    "screen": 130,
+    "screen door": 58,
+    "sculpture": 132,
+    "sea": 26,
+    "seat": 31,
+    "shelf": 24,
+    "ship": 103,
+    "shower": 145,
+    "sidewalk": 11,
+    "signboard": 43,
+    "sink": 47,
+    "sky": 2,
+    "skyscraper": 48,
+    "sofa": 23,
+    "stage": 101,
+    "stairs": 53,
+    "stairway": 59,
+    "step": 121,
+    "stool": 110,
+    "stove": 71,
+    "streetlight": 87,
+    "swimming pool": 109,
+    "swivel chair": 75,
+    "table": 15,
+    "tank": 122,
+    "television receiver": 89,
+    "tent": 114,
+    "toilet": 65,
+    "towel": 81,
+    "tower": 84,
+    "trade name": 123,
+    "traffic light": 136,
+    "tray": 137,
+    "tree": 4,
+    "truck": 83,
+    "van": 102,
+    "vase": 135,
+    "wall": 0,
+    "wardrobe": 35,
+    "washer": 107,
+    "water": 21,
+    "waterfall": 113,
+    "windowpane": 8
+  },
+  "mask_feature_size": 256,
+  "mask_weight": 5.0,
+  "model_type": "mask2former",
+  "no_object_weight": 0.1,
+  "num_attention_heads": 8,
+  "num_hidden_layers": 10,
+  "num_queries": 100,
+  "output_auxiliary_logits": null,
+  "oversample_ratio": 3.0,
+  "pre_norm": false,
+  "torch_dtype": "float32",
+  "train_num_points": 12544,
+  "transformers_version": null,
+  "use_auxiliary_loss": true
+}

coral_seg/pretrained/mask2former-swin-base-ade-semantic/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09e2ba3efa9f18fa6a313c88ef7d862fc15da10ddb4bbc034df54160089e130e
+size 431785608

coral_seg/pretrained/mask2former-swin-base-ade-semantic/preprocessor_config.json

@@ -0,0 +1,27 @@
+{
+  "_max_size": 2560,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "ignore_index": 255,
+  "image_mean": [
+    0.48500001430511475,
+    0.4560000002384186,
+    0.4059999883174896
+  ],
+  "image_processor_type": "Mask2FormerImageProcessor",
+  "image_std": [
+    0.2290000021457672,
+    0.2239999920129776,
+    0.22499999403953552
+  ],
+  "num_labels": 150,
+  "reduce_labels": false,
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 384,
+    "width": 384
+  },
+  "size_divisor": 32
+}

coral_seg/pretrained/mask2former-swin-base-ade-semantic/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:197bab4870fea7287635f62fe52538a4cf053767ddd0f2c9cb7611deca618f1d
+size 431950789

coral_seg/requirements.txt

@@ -0,0 +1,11 @@
+torch==2.3.0
+torchvision==0.18.0
+transformers==4.46.3
+timm==1.0.27
+albumentations==2.0.8
+opencv-python-headless==4.13.0.92
+safetensors==0.8.0
+accelerate==1.14.0
+numpy>=1.26
+Pillow>=10.0
+PyYAML>=6.0

coral_seg/splits/train.txt

@@ -0,0 +1,2550 @@
+0000
+0001
+0002
+0004
+0005
+0006
+0007
+0009
+0011
+0012
+0013
+0015
+0016
+0017
+0018
+0020
+0021
+0022
+0023
+0025
+0026
+0027
+0028
+0030
+0031
+0032
+0033
+0036
+0037
+0038
+0039
+0040
+0041
+0042
+0043
+0044
+0046
+0047
+0049
+0050
+0051
+0052
+0054
+0055
+0056
+0058
+0059
+0060
+0064
+0065
+0067
+0068
+0069
+0070
+0071
+0072
+0073
+0074
+0075
+0076
+0077
+0078
+0080
+0081
+0082
+0083
+0085
+0086
+0087
+0088
+0089
+0090
+0091
+0092
+0093
+0094
+0095
+0096
+0097
+0098
+0100
+0101
+0102
+0103
+0105
+0107
+0108
+0110
+0111
+0113
+0114
+0115
+0116
+0117
+0118
+0119
+0120
+0121
+0122
+0123
+0124
+0125
+0126
+0127
+0128
+0129
+0131
+0132
+0133
+0134
+0137
+0138
+0139
+0140
+0141
+0142
+0143
+0144
+0145
+0146
+0148
+0149
+0150
+0151
+0152
+0153
+0154
+0155
+0156
+0157
+0158
+0159
+0160
+0162
+0163
+0164
+0165
+0166
+0168
+0169
+0170
+0171
+0172
+0174
+0175
+0176
+0178
+0179
+0180
+0181
+0182
+0183
+0184
+0185
+0186
+0187
+0188
+0189
+0190
+0191
+0192
+0193
+0194
+0195
+0197
+0198
+0199
+0200
+0201
+0202
+0203
+0204
+0205
+0206
+0208
+0209
+0210
+0211
+0212
+0213
+0214
+0215
+0216
+0217
+0218
+0219
+0220
+0221
+0222
+0224
+0225
+0227
+0228
+0229
+0230
+0231
+0232
+0233
+0234
+0235
+0236
+0237
+0238
+0239
+0240
+0241
+0242
+0243
+0244
+0245
+0246
+0247
+0248
+0249
+0250
+0251
+0252
+0253
+0254
+0255
+0256
+0257
+0258
+0259
+0260
+0261
+0262
+0263
+0264
+0265
+0266
+0267
+0268
+0269
+0270
+0273
+0274
+0275
+0277
+0278
+0279
+0281
+0282
+0283
+0284
+0285
+0286
+0287
+0288
+0289
+0290
+0292
+0293
+0294
+0295
+0296
+0297
+0298
+0299
+0300
+0302
+0303
+0304
+0305
+0306
+0307
+0308
+0309
+0310
+0311
+0312
+0313
+0314
+0315
+0316
+0317
+0318
+0319
+0320
+0321
+0322
+0323
+0325
+0326
+0327
+0328
+0329
+0330
+0331
+0332
+0334
+0336
+0337
+0338
+0339
+0340
+0341
+0342
+0344
+0345
+0346
+0349
+0351
+0352
+0355
+0356
+0357
+0358
+0359
+0361
+0362
+0364
+0365
+0366
+0367
+0368
+0371
+0372
+0373
+0374
+0375
+0376
+0377
+0379
+0381
+0382
+0383
+0384
+0385
+0386
+0387
+0388
+0389
+0390
+0391
+0393
+0394
+0395
+0396
+0397
+0398
+0400
+0401
+0402
+0403
+0404
+0405
+0406
+0407
+0408
+0409
+0410
+0411
+0413
+0414
+0415
+0416
+0417
+0418
+0419
+0420
+0421
+0422
+0423
+0424
+0425
+0426
+0427
+0429
+0430
+0431
+0432
+0434
+0436
+0437
+0438
+0439
+0440
+0441
+0442
+0443
+0445
+0446
+0447
+0448
+0449
+0451
+0452
+0453
+0454
+0455
+0456
+0457
+0458
+0459
+0460
+0461
+0463
+0464
+0465
+0466
+0467
+0468
+0469
+0471
+0472
+0473
+0474
+0475
+0476
+0477
+0478
+0479
+0480
+0481
+0482
+0483
+0484
+0486
+0487
+0488
+0490
+0491
+0492
+0493
+0495
+0496
+0498
+0500
+0501
+0502
+0503
+0504
+0505
+0506
+0508
+0509
+0510
+0511
+0512
+0513
+0515
+0516
+0517
+0518
+0519
+0520
+0521
+0522
+0523
+0524
+0525
+0526
+0528
+0529
+0531
+0532
+0534
+0535
+0536
+0537
+0538
+0539
+0540
+0542
+0543
+0545
+0546
+0548
+0549
+0550
+0551
+0554
+0556
+0557
+0558
+0559
+0560
+0561
+0562
+0563
+0564
+0565
+0566
+0567
+0568
+0569
+0571
+0572
+0573
+0574
+0575
+0576
+0577
+0578
+0579
+0580
+0581
+0582
+0583
+0584
+0585
+0586
+0588
+0589
+0590
+0591
+0592
+0594
+0595
+0596
+0597
+0598
+0599
+0600
+0601
+0602
+0603
+0604
+0605
+0606
+0607
+0608
+0609
+0610
+0611
+0613
+0614
+0615
+0616
+0617
+0618
+0619
+0620
+0621
+0622
+0623
+0624
+0625
+0626
+0627
+0628
+0629
+0630
+0631
+0632
+0633
+0634
+0635
+0636
+0637
+0638
+0639
+0640
+0642
+0643
+0644
+0645
+0646
+0647
+0648
+0649
+0650
+0651
+0652
+0653
+0654
+0655
+0656
+0657
+0658
+0660
+0661
+0662
+0663
+0664
+0665
+0666
+0667
+0668
+0669
+0671
+0672
+0673
+0674
+0675
+0676
+0677
+0678
+0679
+0680
+0681
+0682
+0683
+0684
+0685
+0686
+0688
+0689
+0690
+0691
+0692
+0693
+0696
+0697
+0698
+0699
+0700
+0701
+0702
+0704
+0705
+0706
+0707
+0708
+0709
+0710
+0711
+0712
+0713
+0714
+0715
+0716
+0718
+0719
+0721
+0722
+0723
+0725
+0726
+0727
+0728
+0729
+0731
+0732
+0733
+0734
+0735
+0736
+0737
+0740
+0741
+0742
+0743
+0744
+0745
+0746
+0747
+0748
+0749
+0750
+0751
+0752
+0754
+0755
+0756
+0759
+0760
+0761
+0762
+0763
+0764
+0765
+0768
+0769
+0770
+0771
+0772
+0773
+0774
+0775
+0776
+0777
+0778
+0780
+0781
+0782
+0783
+0784
+0786
+0787
+0789
+0790
+0791
+0792
+0794
+0795
+0796
+0797
+0799
+0800
+0801
+0802
+0803
+0804
+0805
+0806
+0807
+0809
+0810
+0811
+0812
+0816
+0817
+0818
+0819
+0820
+0821
+0823
+0824
+0826
+0827
+0828
+0829
+0831
+0832
+0833
+0835
+0836
+0837
+0838
+0839
+0840
+0841
+0842
+0843
+0844
+0845
+0846
+0847
+0848
+0849
+0850
+0852
+0854
+0855
+0856
+0857
+0858
+0859
+0860
+0861
+0862
+0863
+0864
+0865
+0866
+0867
+0869
+0870
+0871
+0873
+0874
+0875
+0876
+0877
+0878
+0879
+0880
+0881
+0883
+0884
+0885
+0886
+0888
+0890
+0891
+0892
+0893
+0895
+0896
+0898
+0899
+0900
+0902
+0903
+0904
+0905
+0907
+0908
+0910
+0911
+0913
+0914
+0917
+0918
+0919
+0920
+0921
+0922
+0923
+0924
+0927
+0928
+0929
+0931
+0932
+0933
+0934
+0935
+0936
+0937
+0938
+0939
+0940
+0941
+0942
+0943
+0944
+0945
+0946
+0947
+0948
+0949
+0950
+0951
+0954
+0955
+0957
+0958
+0959
+0960
+0962
+0963
+0964
+0966
+0967
+0968
+0969
+0972
+0973
+0974
+0975
+0976
+0979
+0980
+0981
+0982
+0983
+0984
+0985
+0986
+0987
+0988
+0990
+0991
+0992
+0993
+0994
+0995
+0996
+0997
+0998
+0999
+1000
+1001
+1002
+1003
+1004
+1005
+1006
+1007
+1008
+1009
+1010
+1011
+1012
+1013
+1014
+1015
+1016
+1017
+1018
+1019
+1022
+1024
+1025
+1026
+1027
+1028
+1029
+1030
+1031
+1032
+1033
+1034
+1035
+1036
+1037
+1038
+1039
+1040
+1041
+1042
+1043
+1044
+1046
+1047
+1048
+1050
+1053
+1054
+1056
+1057
+1058
+1059
+1061
+1062
+1063
+1065
+1066
+1068
+1070
+1071
+1072
+1073
+1074
+1075
+1076
+1077
+1078
+1080
+1081
+1082
+1083
+1084
+1085
+1086
+1087
+1088
+1089
+1090
+1092
+1093
+1094
+1095
+1096
+1097
+1098
+1100
+1101
+1103
+1104
+1105
+1107
+1109
+1112
+1114
+1115
+1116
+1117
+1119
+1120
+1122
+1125
+1126
+1127
+1128
+1129
+1130
+1131
+1132
+1133
+1134
+1135
+1136
+1138
+1139
+1142
+1143
+1144
+1145
+1146
+1147
+1148
+1149
+1150
+1151
+1152
+1153
+1154
+1155
+1156
+1157
+1158
+1159
+1160
+1161
+1163
+1164
+1165
+1166
+1167
+1168
+1171
+1172
+1173
+1174
+1175
+1177
+1179
+1181
+1182
+1183
+1184
+1186
+1187
+1188
+1189
+1190
+1191
+1192
+1193
+1194
+1195
+1196
+1198
+1200
+1201
+1203
+1205
+1207
+1208
+1209
+1210
+1211
+1212
+1213
+1214
+1215
+1216
+1217
+1218
+1219
+1220
+1221
+1222
+1223
+1224
+1225
+1226
+1227
+1228
+1229
+1230
+1231
+1232
+1233
+1234
+1236
+1237
+1238
+1239
+1240
+1241
+1243
+1244
+1245
+1246
+1247
+1248
+1249
+1250
+1252
+1253
+1254
+1255
+1256
+1257
+1258
+1259
+1260
+1261
+1262
+1264
+1265
+1266
+1268
+1269
+1270
+1271
+1272
+1273
+1274
+1275
+1276
+1277
+1278
+1279
+1280
+1281
+1282
+1283
+1285
+1286
+1287
+1288
+1289
+1290
+1291
+1292
+1293
+1294
+1295
+1296
+1298
+1299
+1300
+1301
+1302
+1303
+1305
+1306
+1307
+1308
+1309
+1310
+1311
+1312
+1313
+1314
+1315
+1316
+1317
+1318
+1319
+1320
+1321
+1322
+1323
+1324
+1325
+1326
+1327
+1328
+1329
+1330
+1332
+1333
+1334
+1335
+1336
+1337
+1338
+1339
+1340
+1341
+1343
+1344
+1345
+1347
+1348
+1349
+1350
+1351
+1353
+1354
+1355
+1356
+1358
+1359
+1360
+1361
+1362
+1363
+1364
+1365
+1366
+1367
+1368
+1370
+1371
+1372
+1373
+1374
+1377
+1378
+1379
+1380
+1381
+1384
+1386
+1388
+1390
+1391
+1392
+1393
+1394
+1395
+1396
+1398
+1400
+1401
+1402
+1403
+1404
+1405
+1406
+1407
+1408
+1409
+1410
+1411
+1413
+1414
+1416
+1417
+1418
+1419
+1420
+1422
+1424
+1425
+1427
+1428
+1429
+1430
+1431
+1432
+1433
+1434
+1437
+1438
+1439
+1440
+1441
+1442
+1443
+1444
+1445
+1447
+1448
+1449
+1451
+1452
+1453
+1454
+1455
+1456
+1457
+1458
+1459
+1460
+1461
+1462
+1463
+1464
+1465
+1466
+1467
+1468
+1469
+1470
+1471
+1472
+1473
+1474
+1475
+1476
+1477
+1478
+1479
+1480
+1481
+1482
+1483
+1484
+1485
+1487
+1488
+1489
+1491
+1493
+1494
+1496
+1498
+1499
+1500
+1501
+1503
+1504
+1505
+1506
+1507
+1508
+1510
+1512
+1513
+1514
+1515
+1516
+1517
+1518
+1519
+1520
+1521
+1524
+1526
+1527
+1528
+1529
+1530
+1531
+1533
+1534
+1535
+1537
+1539
+1542
+1543
+1544
+1545
+1546
+1547
+1548
+1550
+1551
+1552
+1553
+1554
+1555
+1556
+1557
+1558
+1559
+1560
+1561
+1562
+1563
+1564
+1565
+1566
+1567
+1569
+1570
+1572
+1573
+1574
+1575
+1577
+1578
+1579
+1580
+1582
+1583
+1585
+1586
+1588
+1589
+1590
+1591
+1593
+1594
+1595
+1596
+1597
+1598
+1599
+1600
+1601
+1602
+1603
+1606
+1607
+1608
+1610
+1611
+1612
+1613
+1614
+1616
+1617
+1618
+1619
+1620
+1621
+1622
+1623
+1625
+1626
+1627
+1628
+1629
+1630
+1631
+1632
+1633
+1634
+1635
+1636
+1638
+1640
+1641
+1642
+1643
+1644
+1645
+1646
+1647
+1649
+1650
+1651
+1652
+1653
+1655
+1656
+1657
+1658
+1659
+1660
+1661
+1662
+1663
+1664
+1665
+1666
+1668
+1669
+1671
+1672
+1673
+1674
+1675
+1677
+1678
+1679
+1681
+1683
+1684
+1685
+1686
+1687
+1688
+1690
+1691
+1692
+1693
+1694
+1695
+1696
+1697
+1698
+1699
+1700
+1703
+1704
+1705
+1706
+1708
+1709
+1712
+1714
+1715
+1716
+1718
+1720
+1722
+1723
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
+1733
+1734
+1735
+1736
+1737
+1738
+1739
+1740
+1741
+1742
+1743
+1744
+1745
+1746
+1747
+1749
+1750
+1751
+1752
+1754
+1756
+1757
+1758
+1759
+1760
+1761
+1763
+1764
+1765
+1766
+1767
+1768
+1770
+1771
+1772
+1775
+1776
+1777
+1778
+1781
+1783
+1785
+1786
+1787
+1788
+1789
+1790
+1791
+1792
+1794
+1795
+1796
+1797
+1798
+1799
+1800
+1802
+1803
+1804
+1806
+1807
+1809
+1810
+1811
+1812
+1813
+1814
+1816
+1817
+1818
+1820
+1821
+1822
+1823
+1824
+1825
+1826
+1827
+1828
+1829
+1830
+1831
+1832
+1833
+1834
+1835
+1836
+1837
+1838
+1839
+1840
+1842
+1843
+1844
+1845
+1846
+1847
+1848
+1849
+1852
+1855
+1856
+1857
+1858
+1859
+1860
+1861
+1862
+1863
+1866
+1870
+1871
+1872
+1873
+1874
+1875
+1876
+1877
+1879
+1880
+1882
+1883
+1884
+1885
+1886
+1887
+1890
+1891
+1892
+1893
+1895
+1896
+1897
+1898
+1899
+1900
+1901
+1902
+1903
+1904
+1905
+1907
+1908
+1909
+1911
+1912
+1913
+1914
+1915
+1916
+1917
+1918
+1919
+1921
+1922
+1923
+1924
+1925
+1926
+1927
+1928
+1929
+1930
+1931
+1932
+1933
+1934
+1935
+1936
+1937
+1938
+1941
+1942
+1943
+1944
+1946
+1947
+1948
+1950
+1951
+1952
+1953
+1954
+1955
+1956
+1957
+1958
+1959
+1960
+1961
+1962
+1963
+1964
+1965
+1966
+1967
+1968
+1969
+1970
+1971
+1972
+1973
+1974
+1975
+1976
+1977
+1978
+1979
+1980
+1981
+1982
+1984
+1985
+1986
+1988
+1989
+1991
+1992
+1993
+1994
+1995
+1996
+1998
+1999
+2001
+2002
+2003
+2004
+2005
+2006
+2007
+2009
+2010
+2011
+2012
+2013
+2014
+2015
+2016
+2017
+2018
+2019
+2020
+2021
+2022
+2023
+2024
+2025
+2026
+2027
+2028
+2029
+2030
+2032
+2033
+2034
+2035
+2036
+2037
+2038
+2039
+2040
+2041
+2043
+2044
+2045
+2046
+2047
+2048
+2049
+2051
+2052
+2054
+2055
+2057
+2058
+2059
+2060
+2062
+2063
+2064
+2065
+2066
+2067
+2069
+2070
+2071
+2072
+2073
+2074
+2075
+2077
+2078
+2079
+2080
+2081
+2082
+2083
+2084
+2085
+2086
+2087
+2088
+2089
+2090
+2093
+2094
+2095
+2096
+2097
+2098
+2100
+2101
+2102
+2103
+2104
+2105
+2106
+2107
+2108
+2109
+2110
+2111
+2112
+2114
+2115
+2116
+2117
+2118
+2119
+2120
+2121
+2122
+2123
+2124
+2126
+2127
+2129
+2130
+2131
+2132
+2133
+2134
+2135
+2136
+2137
+2138
+2139
+2140
+2141
+2142
+2143
+2144
+2145
+2147
+2149
+2150
+2151
+2152
+2153
+2154
+2155
+2156
+2157
+2158
+2160
+2161
+2162
+2163
+2164
+2165
+2166
+2167
+2168
+2170
+2171
+2172
+2173
+2175
+2176
+2177
+2178
+2179
+2180
+2181
+2182
+2184
+2185
+2186
+2187
+2189
+2190
+2191
+2192
+2193
+2195
+2196
+2197
+2198
+2199
+2200
+2201
+2202
+2203
+2204
+2205
+2206
+2207
+2208
+2210
+2211
+2212
+2213
+2214
+2215
+2216
+2217
+2218
+2219
+2220
+2221
+2222
+2223
+2224
+2225
+2226
+2227
+2228
+2229
+2231
+2232
+2233
+2234
+2236
+2238
+2239
+2240
+2241
+2242
+2244
+2245
+2246
+2247
+2249
+2250
+2251
+2252
+2253
+2254
+2255
+2256
+2257
+2258
+2259
+2260
+2261
+2262
+2263
+2264
+2265
+2266
+2267
+2268
+2270
+2271
+2272
+2273
+2274
+2275
+2276
+2278
+2279
+2280
+2281
+2282
+2283
+2284
+2285
+2287
+2288
+2289
+2290
+2291
+2292
+2293
+2294
+2295
+2296
+2297
+2299
+2301
+2302
+2303
+2304
+2305
+2306
+2307
+2308
+2309
+2310
+2312
+2313
+2315
+2316
+2317
+2318
+2319
+2320
+2321
+2322
+2323
+2324
+2325
+2326
+2327
+2329
+2330
+2331
+2332
+2333
+2335
+2336
+2337
+2338
+2339
+2341
+2342
+2343
+2346
+2347
+2349
+2350
+2352
+2353
+2354
+2355
+2356
+2357
+2359
+2360
+2361
+2363
+2364
+2365
+2366
+2367
+2368
+2369
+2370
+2371
+2373
+2374
+2375
+2376
+2378
+2379
+2380
+2381
+2382
+2383
+2384
+2385
+2386
+2387
+2388
+2389
+2390
+2391
+2392
+2393
+2394
+2396
+2398
+2399
+2400
+2401
+2402
+2403
+2404
+2405
+2407
+2408
+2409
+2410
+2411
+2412
+2413
+2414
+2417
+2418
+2420
+2421
+2422
+2423
+2424
+2425
+2426
+2427
+2429
+2431
+2432
+2434
+2436
+2439
+2440
+2441
+2442
+2443
+2444
+2445
+2446
+2447
+2448
+2449
+2451
+2452
+2454
+2455
+2456
+2457
+2458
+2460
+2461
+2462
+2463
+2464
+2465
+2466
+2467
+2468
+2469
+2470
+2471
+2472
+2473
+2474
+2475
+2476
+2477
+2478
+2479
+2480
+2481
+2482
+2483
+2484
+2486
+2487
+2488
+2489
+2490
+2491
+2494
+2496
+2497
+2498
+2499
+2500
+2501
+2502
+2504
+2505
+2506
+2507
+2508
+2510
+2511
+2512
+2513
+2514
+2515
+2516
+2518
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2527
+2528
+2529
+2530
+2531
+2532
+2533
+2534
+2536
+2537
+2538
+2539
+2540
+2541
+2543
+2544
+2545
+2546
+2547
+2548
+2549
+2550
+2551
+2552
+2553
+2554
+2555
+2556
+2557
+2558
+2559
+2560
+2561
+2562
+2563
+2564
+2565
+2566
+2567
+2568
+2570
+2571
+2572
+2573
+2574
+2575
+2576
+2577
+2578
+2579
+2580
+2581
+2582
+2583
+2584
+2586
+2587
+2588
+2589
+2590
+2591
+2592
+2594
+2595
+2596
+2598
+2600
+2601
+2602
+2604
+2605
+2606
+2607
+2608
+2612
+2615
+2616
+2617
+2618
+2620
+2621
+2622
+2623
+2624
+2625
+2626
+2628
+2629
+2630
+2631
+2632
+2636
+2637
+2638
+2639
+2640
+2641
+2642
+2643
+2644
+2645
+2646
+2647
+2648
+2649
+2650
+2651
+2652
+2653
+2655
+2656
+2657
+2658
+2659
+2661
+2662
+2663
+2664
+2665
+2666
+2667
+2668
+2669
+2670
+2672
+2673
+2674
+2675
+2676
+2677
+2680
+2682
+2683
+2684
+2686
+2687
+2689
+2690
+2691
+2692
+2693
+2694
+2695
+2696
+2697
+2698
+2699
+2700
+2701
+2702
+2703
+2704
+2705
+2706
+2707
+2709
+2710
+2713
+2714
+2715
+2716
+2717
+2718
+2719
+2720
+2721
+2722
+2723
+2726
+2727
+2728
+2729
+2730
+2732
+2733
+2734
+2735
+2736
+2737
+2738
+2740
+2741
+2743
+2744
+2745
+2746
+2747
+2749
+2750
+2751
+2752
+2753
+2755
+2756
+2758
+2759
+2760
+2761
+2762
+2764
+2765
+2766
+2767
+2768
+2769
+2770
+2771
+2772
+2775
+2776
+2777
+2780
+2781
+2782
+2783
+2784
+2786
+2788
+2789
+2790
+2791
+2792
+2793
+2794
+2795
+2796
+2797
+2798
+2799
+2800
+2802
+2804
+2805
+2806
+2807
+2808
+2809
+2810
+2811
+2812
+2813
+2814
+2815
+2816
+2817
+2818
+2819
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+2831
+2832
+2833
+2834
+2835
+2836
+2837
+2838
+2839
+2840
+2842
+2844
+2845
+2846
+2847
+2848
+2850
+2851
+2852
+2853
+2854
+2855
+2856
+2857
+2858
+2859
+2860
+2861
+2862
+2863
+2864
+2865
+2866
+2867
+2868
+2869
+2870
+2871
+2873
+2874
+2875
+2876
+2877
+2878
+2879
+2881
+2882
+2883
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2913
+2914
+2915
+2916
+2917
+2918
+2919
+2920
+2921
+2923
+2925
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+2936
+2937
+2938
+2939
+2940
+2941
+2942
+2943
+2944
+2945
+2946
+2947
+2948
+2950
+2951
+2952
+2953
+2954
+2955
+2956
+2957
+2958
+2959
+2960
+2962
+2964
+2965
+2966
+2967
+2968
+2969
+2970
+2971
+2972
+2973
+2974
+2977
+2978
+2979
+2980
+2981
+2982
+2984
+2987
+2988
+2990
+2991
+2992
+2993
+2994
+2995
+2998
+2999

coral_seg/splits/train_full.txt

@@ -0,0 +1,3000 @@
+0000
+0001
+0002
+0003
+0004
+0005
+0006
+0007
+0008
+0009
+0010
+0011
+0012
+0013
+0014
+0015
+0016
+0017
+0018
+0019
+0020
+0021
+0022
+0023
+0024
+0025
+0026
+0027
+0028
+0029
+0030
+0031
+0032
+0033
+0034
+0035
+0036
+0037
+0038
+0039
+0040
+0041
+0042
+0043
+0044
+0045
+0046
+0047
+0048
+0049
+0050
+0051
+0052
+0053
+0054
+0055
+0056
+0057
+0058
+0059
+0060
+0061
+0062
+0063
+0064
+0065
+0066
+0067
+0068
+0069
+0070
+0071
+0072
+0073
+0074
+0075
+0076
+0077
+0078
+0079
+0080
+0081
+0082
+0083
+0084
+0085
+0086
+0087
+0088
+0089
+0090
+0091
+0092
+0093
+0094
+0095
+0096
+0097
+0098
+0099
+0100
+0101
+0102
+0103
+0104
+0105
+0106
+0107
+0108
+0109
+0110
+0111
+0112
+0113
+0114
+0115
+0116
+0117
+0118
+0119
+0120
+0121
+0122
+0123
+0124
+0125
+0126
+0127
+0128
+0129
+0130
+0131
+0132
+0133
+0134
+0135
+0136
+0137
+0138
+0139
+0140
+0141
+0142
+0143
+0144
+0145
+0146
+0147
+0148
+0149
+0150
+0151
+0152
+0153
+0154
+0155
+0156
+0157
+0158
+0159
+0160
+0161
+0162
+0163
+0164
+0165
+0166
+0167
+0168
+0169
+0170
+0171
+0172
+0173
+0174
+0175
+0176
+0177
+0178
+0179
+0180
+0181
+0182
+0183
+0184
+0185
+0186
+0187
+0188
+0189
+0190
+0191
+0192
+0193
+0194
+0195
+0196
+0197
+0198
+0199
+0200
+0201
+0202
+0203
+0204
+0205
+0206
+0207
+0208
+0209
+0210
+0211
+0212
+0213
+0214
+0215
+0216
+0217
+0218
+0219
+0220
+0221
+0222
+0223
+0224
+0225
+0226
+0227
+0228
+0229
+0230
+0231
+0232
+0233
+0234
+0235
+0236
+0237
+0238
+0239
+0240
+0241
+0242
+0243
+0244
+0245
+0246
+0247
+0248
+0249
+0250
+0251
+0252
+0253
+0254
+0255
+0256
+0257
+0258
+0259
+0260
+0261
+0262
+0263
+0264
+0265
+0266
+0267
+0268
+0269
+0270
+0271
+0272
+0273
+0274
+0275
+0276
+0277
+0278
+0279
+0280
+0281
+0282
+0283
+0284
+0285
+0286
+0287
+0288
+0289
+0290
+0291
+0292
+0293
+0294
+0295
+0296
+0297
+0298
+0299
+0300
+0301
+0302
+0303
+0304
+0305
+0306
+0307
+0308
+0309
+0310
+0311
+0312
+0313
+0314
+0315
+0316
+0317
+0318
+0319
+0320
+0321
+0322
+0323
+0324
+0325
+0326
+0327
+0328
+0329
+0330
+0331
+0332
+0333
+0334
+0335
+0336
+0337
+0338
+0339
+0340
+0341
+0342
+0343
+0344
+0345
+0346
+0347
+0348
+0349
+0350
+0351
+0352
+0353
+0354
+0355
+0356
+0357
+0358
+0359
+0360
+0361
+0362
+0363
+0364
+0365
+0366
+0367
+0368
+0369
+0370
+0371
+0372
+0373
+0374
+0375
+0376
+0377
+0378
+0379
+0380
+0381
+0382
+0383
+0384
+0385
+0386
+0387
+0388
+0389
+0390
+0391
+0392
+0393
+0394
+0395
+0396
+0397
+0398
+0399
+0400
+0401
+0402
+0403
+0404
+0405
+0406
+0407
+0408
+0409
+0410
+0411
+0412
+0413
+0414
+0415
+0416
+0417
+0418
+0419
+0420
+0421
+0422
+0423
+0424
+0425
+0426
+0427
+0428
+0429
+0430
+0431
+0432
+0433
+0434
+0435
+0436
+0437
+0438
+0439
+0440
+0441
+0442
+0443
+0444
+0445
+0446
+0447
+0448
+0449
+0450
+0451
+0452
+0453
+0454
+0455
+0456
+0457
+0458
+0459
+0460
+0461
+0462
+0463
+0464
+0465
+0466
+0467
+0468
+0469
+0470
+0471
+0472
+0473
+0474
+0475
+0476
+0477
+0478
+0479
+0480
+0481
+0482
+0483
+0484
+0485
+0486
+0487
+0488
+0489
+0490
+0491
+0492
+0493
+0494
+0495
+0496
+0497
+0498
+0499
+0500
+0501
+0502
+0503
+0504
+0505
+0506
+0507
+0508
+0509
+0510
+0511
+0512
+0513
+0514
+0515
+0516
+0517
+0518
+0519
+0520
+0521
+0522
+0523
+0524
+0525
+0526
+0527
+0528
+0529
+0530
+0531
+0532
+0533
+0534
+0535
+0536
+0537
+0538
+0539
+0540
+0541
+0542
+0543
+0544
+0545
+0546
+0547
+0548
+0549
+0550
+0551
+0552
+0553
+0554
+0555
+0556
+0557
+0558
+0559
+0560
+0561
+0562
+0563
+0564
+0565
+0566
+0567
+0568
+0569
+0570
+0571
+0572
+0573
+0574
+0575
+0576
+0577
+0578
+0579
+0580
+0581
+0582
+0583
+0584
+0585
+0586
+0587
+0588
+0589
+0590
+0591
+0592
+0593
+0594
+0595
+0596
+0597
+0598
+0599
+0600
+0601
+0602
+0603
+0604
+0605
+0606
+0607
+0608
+0609
+0610
+0611
+0612
+0613
+0614
+0615
+0616
+0617
+0618
+0619
+0620
+0621
+0622
+0623
+0624
+0625
+0626
+0627
+0628
+0629
+0630
+0631
+0632
+0633
+0634
+0635
+0636
+0637
+0638
+0639
+0640
+0641
+0642
+0643
+0644
+0645
+0646
+0647
+0648
+0649
+0650
+0651
+0652
+0653
+0654
+0655
+0656
+0657
+0658
+0659
+0660
+0661
+0662
+0663
+0664
+0665
+0666
+0667
+0668
+0669
+0670
+0671
+0672
+0673
+0674
+0675
+0676
+0677
+0678
+0679
+0680
+0681
+0682
+0683
+0684
+0685
+0686
+0687
+0688
+0689
+0690
+0691
+0692
+0693
+0694
+0695
+0696
+0697
+0698
+0699
+0700
+0701
+0702
+0703
+0704
+0705
+0706
+0707
+0708
+0709
+0710
+0711
+0712
+0713
+0714
+0715
+0716
+0717
+0718
+0719
+0720
+0721
+0722
+0723
+0724
+0725
+0726
+0727
+0728
+0729
+0730
+0731
+0732
+0733
+0734
+0735
+0736
+0737
+0738
+0739
+0740
+0741
+0742
+0743
+0744
+0745
+0746
+0747
+0748
+0749
+0750
+0751
+0752
+0753
+0754
+0755
+0756
+0757
+0758
+0759
+0760
+0761
+0762
+0763
+0764
+0765
+0766
+0767
+0768
+0769
+0770
+0771
+0772
+0773
+0774
+0775
+0776
+0777
+0778
+0779
+0780
+0781
+0782
+0783
+0784
+0785
+0786
+0787
+0788
+0789
+0790
+0791
+0792
+0793
+0794
+0795
+0796
+0797
+0798
+0799
+0800
+0801
+0802
+0803
+0804
+0805
+0806
+0807
+0808
+0809
+0810
+0811
+0812
+0813
+0814
+0815
+0816
+0817
+0818
+0819
+0820
+0821
+0822
+0823
+0824
+0825
+0826
+0827
+0828
+0829
+0830
+0831
+0832
+0833
+0834
+0835
+0836
+0837
+0838
+0839
+0840
+0841
+0842
+0843
+0844
+0845
+0846
+0847
+0848
+0849
+0850
+0851
+0852
+0853
+0854
+0855
+0856
+0857
+0858
+0859
+0860
+0861
+0862
+0863
+0864
+0865
+0866
+0867
+0868
+0869
+0870
+0871
+0872
+0873
+0874
+0875
+0876
+0877
+0878
+0879
+0880
+0881
+0882
+0883
+0884
+0885
+0886
+0887
+0888
+0889
+0890
+0891
+0892
+0893
+0894
+0895
+0896
+0897
+0898
+0899
+0900
+0901
+0902
+0903
+0904
+0905
+0906
+0907
+0908
+0909
+0910
+0911
+0912
+0913
+0914
+0915
+0916
+0917
+0918
+0919
+0920
+0921
+0922
+0923
+0924
+0925
+0926
+0927
+0928
+0929
+0930
+0931
+0932
+0933
+0934
+0935
+0936
+0937
+0938
+0939
+0940
+0941
+0942
+0943
+0944
+0945
+0946
+0947
+0948
+0949
+0950
+0951
+0952
+0953
+0954
+0955
+0956
+0957
+0958
+0959
+0960
+0961
+0962
+0963
+0964
+0965
+0966
+0967
+0968
+0969
+0970
+0971
+0972
+0973
+0974
+0975
+0976
+0977
+0978
+0979
+0980
+0981
+0982
+0983
+0984
+0985
+0986
+0987
+0988
+0989
+0990
+0991
+0992
+0993
+0994
+0995
+0996
+0997
+0998
+0999
+1000
+1001
+1002
+1003
+1004
+1005
+1006
+1007
+1008
+1009
+1010
+1011
+1012
+1013
+1014
+1015
+1016
+1017
+1018
+1019
+1020
+1021
+1022
+1023
+1024
+1025
+1026
+1027
+1028
+1029
+1030
+1031
+1032
+1033
+1034
+1035
+1036
+1037
+1038
+1039
+1040
+1041
+1042
+1043
+1044
+1045
+1046
+1047
+1048
+1049
+1050
+1051
+1052
+1053
+1054
+1055
+1056
+1057
+1058
+1059
+1060
+1061
+1062
+1063
+1064
+1065
+1066
+1067
+1068
+1069
+1070
+1071
+1072
+1073
+1074
+1075
+1076
+1077
+1078
+1079
+1080
+1081
+1082
+1083
+1084
+1085
+1086
+1087
+1088
+1089
+1090
+1091
+1092
+1093
+1094
+1095
+1096
+1097
+1098
+1099
+1100
+1101
+1102
+1103
+1104
+1105
+1106
+1107
+1108
+1109
+1110
+1111
+1112
+1113
+1114
+1115
+1116
+1117
+1118
+1119
+1120
+1121
+1122
+1123
+1124
+1125
+1126
+1127
+1128
+1129
+1130
+1131
+1132
+1133
+1134
+1135
+1136
+1137
+1138
+1139
+1140
+1141
+1142
+1143
+1144
+1145
+1146
+1147
+1148
+1149
+1150
+1151
+1152
+1153
+1154
+1155
+1156
+1157
+1158
+1159
+1160
+1161
+1162
+1163
+1164
+1165
+1166
+1167
+1168
+1169
+1170
+1171
+1172
+1173
+1174
+1175
+1176
+1177
+1178
+1179
+1180
+1181
+1182
+1183
+1184
+1185
+1186
+1187
+1188
+1189
+1190
+1191
+1192
+1193
+1194
+1195
+1196
+1197
+1198
+1199
+1200
+1201
+1202
+1203
+1204
+1205
+1206
+1207
+1208
+1209
+1210
+1211
+1212
+1213
+1214
+1215
+1216
+1217
+1218
+1219
+1220
+1221
+1222
+1223
+1224
+1225
+1226
+1227
+1228
+1229
+1230
+1231
+1232
+1233
+1234
+1235
+1236
+1237
+1238
+1239
+1240
+1241
+1242
+1243
+1244
+1245
+1246
+1247
+1248
+1249
+1250
+1251
+1252
+1253
+1254
+1255
+1256
+1257
+1258
+1259
+1260
+1261
+1262
+1263
+1264
+1265
+1266
+1267
+1268
+1269
+1270
+1271
+1272
+1273
+1274
+1275
+1276
+1277
+1278
+1279
+1280
+1281
+1282
+1283
+1284
+1285
+1286
+1287
+1288
+1289
+1290
+1291
+1292
+1293
+1294
+1295
+1296
+1297
+1298
+1299
+1300
+1301
+1302
+1303
+1304
+1305
+1306
+1307
+1308
+1309
+1310
+1311
+1312
+1313
+1314
+1315
+1316
+1317
+1318
+1319
+1320
+1321
+1322
+1323
+1324
+1325
+1326
+1327
+1328
+1329
+1330
+1331
+1332
+1333
+1334
+1335
+1336
+1337
+1338
+1339
+1340
+1341
+1342
+1343
+1344
+1345
+1346
+1347
+1348
+1349
+1350
+1351
+1352
+1353
+1354
+1355
+1356
+1357
+1358
+1359
+1360
+1361
+1362
+1363
+1364
+1365
+1366
+1367
+1368
+1369
+1370
+1371
+1372
+1373
+1374
+1375
+1376
+1377
+1378
+1379
+1380
+1381
+1382
+1383
+1384
+1385
+1386
+1387
+1388
+1389
+1390
+1391
+1392
+1393
+1394
+1395
+1396
+1397
+1398
+1399
+1400
+1401
+1402
+1403
+1404
+1405
+1406
+1407
+1408
+1409
+1410
+1411
+1412
+1413
+1414
+1415
+1416
+1417
+1418
+1419
+1420
+1421
+1422
+1423
+1424
+1425
+1426
+1427
+1428
+1429
+1430
+1431
+1432
+1433
+1434
+1435
+1436
+1437
+1438
+1439
+1440
+1441
+1442
+1443
+1444
+1445
+1446
+1447
+1448
+1449
+1450
+1451
+1452
+1453
+1454
+1455
+1456
+1457
+1458
+1459
+1460
+1461
+1462
+1463
+1464
+1465
+1466
+1467
+1468
+1469
+1470
+1471
+1472
+1473
+1474
+1475
+1476
+1477
+1478
+1479
+1480
+1481
+1482
+1483
+1484
+1485
+1486
+1487
+1488
+1489
+1490
+1491
+1492
+1493
+1494
+1495
+1496
+1497
+1498
+1499
+1500
+1501
+1502
+1503
+1504
+1505
+1506
+1507
+1508
+1509
+1510
+1511
+1512
+1513
+1514
+1515
+1516
+1517
+1518
+1519
+1520
+1521
+1522
+1523
+1524
+1525
+1526
+1527
+1528
+1529
+1530
+1531
+1532
+1533
+1534
+1535
+1536
+1537
+1538
+1539
+1540
+1541
+1542
+1543
+1544
+1545
+1546
+1547
+1548
+1549
+1550
+1551
+1552
+1553
+1554
+1555
+1556
+1557
+1558
+1559
+1560
+1561
+1562
+1563
+1564
+1565
+1566
+1567
+1568
+1569
+1570
+1571
+1572
+1573
+1574
+1575
+1576
+1577
+1578
+1579
+1580
+1581
+1582
+1583
+1584
+1585
+1586
+1587
+1588
+1589
+1590
+1591
+1592
+1593
+1594
+1595
+1596
+1597
+1598
+1599
+1600
+1601
+1602
+1603
+1604
+1605
+1606
+1607
+1608
+1609
+1610
+1611
+1612
+1613
+1614
+1615
+1616
+1617
+1618
+1619
+1620
+1621
+1622
+1623
+1624
+1625
+1626
+1627
+1628
+1629
+1630
+1631
+1632
+1633
+1634
+1635
+1636
+1637
+1638
+1639
+1640
+1641
+1642
+1643
+1644
+1645
+1646
+1647
+1648
+1649
+1650
+1651
+1652
+1653
+1654
+1655
+1656
+1657
+1658
+1659
+1660
+1661
+1662
+1663
+1664
+1665
+1666
+1667
+1668
+1669
+1670
+1671
+1672
+1673
+1674
+1675
+1676
+1677
+1678
+1679
+1680
+1681
+1682
+1683
+1684
+1685
+1686
+1687
+1688
+1689
+1690
+1691
+1692
+1693
+1694
+1695
+1696
+1697
+1698
+1699
+1700
+1701
+1702
+1703
+1704
+1705
+1706
+1707
+1708
+1709
+1710
+1711
+1712
+1713
+1714
+1715
+1716
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
+1733
+1734
+1735
+1736
+1737
+1738
+1739
+1740
+1741
+1742
+1743
+1744
+1745
+1746
+1747
+1748
+1749
+1750
+1751
+1752
+1753
+1754
+1755
+1756
+1757
+1758
+1759
+1760
+1761
+1762
+1763
+1764
+1765
+1766
+1767
+1768
+1769
+1770
+1771
+1772
+1773
+1774
+1775
+1776
+1777
+1778
+1779
+1780
+1781
+1782
+1783
+1784
+1785
+1786
+1787
+1788
+1789
+1790
+1791
+1792
+1793
+1794
+1795
+1796
+1797
+1798
+1799
+1800
+1801
+1802
+1803
+1804
+1805
+1806
+1807
+1808
+1809
+1810
+1811
+1812
+1813
+1814
+1815
+1816
+1817
+1818
+1819
+1820
+1821
+1822
+1823
+1824
+1825
+1826
+1827
+1828
+1829
+1830
+1831
+1832
+1833
+1834
+1835
+1836
+1837
+1838
+1839
+1840
+1841
+1842
+1843
+1844
+1845
+1846
+1847
+1848
+1849
+1850
+1851
+1852
+1853
+1854
+1855
+1856
+1857
+1858
+1859
+1860
+1861
+1862
+1863
+1864
+1865
+1866
+1867
+1868
+1869
+1870
+1871
+1872
+1873
+1874
+1875
+1876
+1877
+1878
+1879
+1880
+1881
+1882
+1883
+1884
+1885
+1886
+1887
+1888
+1889
+1890
+1891
+1892
+1893
+1894
+1895
+1896
+1897
+1898
+1899
+1900
+1901
+1902
+1903
+1904
+1905
+1906
+1907
+1908
+1909
+1910
+1911
+1912
+1913
+1914
+1915
+1916
+1917
+1918
+1919
+1920
+1921
+1922
+1923
+1924
+1925
+1926
+1927
+1928
+1929
+1930
+1931
+1932
+1933
+1934
+1935
+1936
+1937
+1938
+1939
+1940
+1941
+1942
+1943
+1944
+1945
+1946
+1947
+1948
+1949
+1950
+1951
+1952
+1953
+1954
+1955
+1956
+1957
+1958
+1959
+1960
+1961
+1962
+1963
+1964
+1965
+1966
+1967
+1968
+1969
+1970
+1971
+1972
+1973
+1974
+1975
+1976
+1977
+1978
+1979
+1980
+1981
+1982
+1983
+1984
+1985
+1986
+1987
+1988
+1989
+1990
+1991
+1992
+1993
+1994
+1995
+1996
+1997
+1998
+1999
+2000
+2001
+2002
+2003
+2004
+2005
+2006
+2007
+2008
+2009
+2010
+2011
+2012
+2013
+2014
+2015
+2016
+2017
+2018
+2019
+2020
+2021
+2022
+2023
+2024
+2025
+2026
+2027
+2028
+2029
+2030
+2031
+2032
+2033
+2034
+2035
+2036
+2037
+2038
+2039
+2040
+2041
+2042
+2043
+2044
+2045
+2046
+2047
+2048
+2049
+2050
+2051
+2052
+2053
+2054
+2055
+2056
+2057
+2058
+2059
+2060
+2061
+2062
+2063
+2064
+2065
+2066
+2067
+2068
+2069
+2070
+2071
+2072
+2073
+2074
+2075
+2076
+2077
+2078
+2079
+2080
+2081
+2082
+2083
+2084
+2085
+2086
+2087
+2088
+2089
+2090
+2091
+2092
+2093
+2094
+2095
+2096
+2097
+2098
+2099
+2100
+2101
+2102
+2103
+2104
+2105
+2106
+2107
+2108
+2109
+2110
+2111
+2112
+2113
+2114
+2115
+2116
+2117
+2118
+2119
+2120
+2121
+2122
+2123
+2124
+2125
+2126
+2127
+2128
+2129
+2130
+2131
+2132
+2133
+2134
+2135
+2136
+2137
+2138
+2139
+2140
+2141
+2142
+2143
+2144
+2145
+2146
+2147
+2148
+2149
+2150
+2151
+2152
+2153
+2154
+2155
+2156
+2157
+2158
+2159
+2160
+2161
+2162
+2163
+2164
+2165
+2166
+2167
+2168
+2169
+2170
+2171
+2172
+2173
+2174
+2175
+2176
+2177
+2178
+2179
+2180
+2181
+2182
+2183
+2184
+2185
+2186
+2187
+2188
+2189
+2190
+2191
+2192
+2193
+2194
+2195
+2196
+2197
+2198
+2199
+2200
+2201
+2202
+2203
+2204
+2205
+2206
+2207
+2208
+2209
+2210
+2211
+2212
+2213
+2214
+2215
+2216
+2217
+2218
+2219
+2220
+2221
+2222
+2223
+2224
+2225
+2226
+2227
+2228
+2229
+2230
+2231
+2232
+2233
+2234
+2235
+2236
+2237
+2238
+2239
+2240
+2241
+2242
+2243
+2244
+2245
+2246
+2247
+2248
+2249
+2250
+2251
+2252
+2253
+2254
+2255
+2256
+2257
+2258
+2259
+2260
+2261
+2262
+2263
+2264
+2265
+2266
+2267
+2268
+2269
+2270
+2271
+2272
+2273
+2274
+2275
+2276
+2277
+2278
+2279
+2280
+2281
+2282
+2283
+2284
+2285
+2286
+2287
+2288
+2289
+2290
+2291
+2292
+2293
+2294
+2295
+2296
+2297
+2298
+2299
+2300
+2301
+2302
+2303
+2304
+2305
+2306
+2307
+2308
+2309
+2310
+2311
+2312
+2313
+2314
+2315
+2316
+2317
+2318
+2319
+2320
+2321
+2322
+2323
+2324
+2325
+2326
+2327
+2328
+2329
+2330
+2331
+2332
+2333
+2334
+2335
+2336
+2337
+2338
+2339
+2340
+2341
+2342
+2343
+2344
+2345
+2346
+2347
+2348
+2349
+2350
+2351
+2352
+2353
+2354
+2355
+2356
+2357
+2358
+2359
+2360
+2361
+2362
+2363
+2364
+2365
+2366
+2367
+2368
+2369
+2370
+2371
+2372
+2373
+2374
+2375
+2376
+2377
+2378
+2379
+2380
+2381
+2382
+2383
+2384
+2385
+2386
+2387
+2388
+2389
+2390
+2391
+2392
+2393
+2394
+2395
+2396
+2397
+2398
+2399
+2400
+2401
+2402
+2403
+2404
+2405
+2406
+2407
+2408
+2409
+2410
+2411
+2412
+2413
+2414
+2415
+2416
+2417
+2418
+2419
+2420
+2421
+2422
+2423
+2424
+2425
+2426
+2427
+2428
+2429
+2430
+2431
+2432
+2433
+2434
+2435
+2436
+2437
+2438
+2439
+2440
+2441
+2442
+2443
+2444
+2445
+2446
+2447
+2448
+2449
+2450
+2451
+2452
+2453
+2454
+2455
+2456
+2457
+2458
+2459
+2460
+2461
+2462
+2463
+2464
+2465
+2466
+2467
+2468
+2469
+2470
+2471
+2472
+2473
+2474
+2475
+2476
+2477
+2478
+2479
+2480
+2481
+2482
+2483
+2484
+2485
+2486
+2487
+2488
+2489
+2490
+2491
+2492
+2493
+2494
+2495
+2496
+2497
+2498
+2499
+2500
+2501
+2502
+2503
+2504
+2505
+2506
+2507
+2508
+2509
+2510
+2511
+2512
+2513
+2514
+2515
+2516
+2517
+2518
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2526
+2527
+2528
+2529
+2530
+2531
+2532
+2533
+2534
+2535
+2536
+2537
+2538
+2539
+2540
+2541
+2542
+2543
+2544
+2545
+2546
+2547
+2548
+2549
+2550
+2551
+2552
+2553
+2554
+2555
+2556
+2557
+2558
+2559
+2560
+2561
+2562
+2563
+2564
+2565
+2566
+2567
+2568
+2569
+2570
+2571
+2572
+2573
+2574
+2575
+2576
+2577
+2578
+2579
+2580
+2581
+2582
+2583
+2584
+2585
+2586
+2587
+2588
+2589
+2590
+2591
+2592
+2593
+2594
+2595
+2596
+2597
+2598
+2599
+2600
+2601
+2602
+2603
+2604
+2605
+2606
+2607
+2608
+2609
+2610
+2611
+2612
+2613
+2614
+2615
+2616
+2617
+2618
+2619
+2620
+2621
+2622
+2623
+2624
+2625
+2626
+2627
+2628
+2629
+2630
+2631
+2632
+2633
+2634
+2635
+2636
+2637
+2638
+2639
+2640
+2641
+2642
+2643
+2644
+2645
+2646
+2647
+2648
+2649
+2650
+2651
+2652
+2653
+2654
+2655
+2656
+2657
+2658
+2659
+2660
+2661
+2662
+2663
+2664
+2665
+2666
+2667
+2668
+2669
+2670
+2671
+2672
+2673
+2674
+2675
+2676
+2677
+2678
+2679
+2680
+2681
+2682
+2683
+2684
+2685
+2686
+2687
+2688
+2689
+2690
+2691
+2692
+2693
+2694
+2695
+2696
+2697
+2698
+2699
+2700
+2701
+2702
+2703
+2704
+2705
+2706
+2707
+2708
+2709
+2710
+2711
+2712
+2713
+2714
+2715
+2716
+2717
+2718
+2719
+2720
+2721
+2722
+2723
+2724
+2725
+2726
+2727
+2728
+2729
+2730
+2731
+2732
+2733
+2734
+2735
+2736
+2737
+2738
+2739
+2740
+2741
+2742
+2743
+2744
+2745
+2746
+2747
+2748
+2749
+2750
+2751
+2752
+2753
+2754
+2755
+2756
+2757
+2758
+2759
+2760
+2761
+2762
+2763
+2764
+2765
+2766
+2767
+2768
+2769
+2770
+2771
+2772
+2773
+2774
+2775
+2776
+2777
+2778
+2779
+2780
+2781
+2782
+2783
+2784
+2785
+2786
+2787
+2788
+2789
+2790
+2791
+2792
+2793
+2794
+2795
+2796
+2797
+2798
+2799
+2800
+2801
+2802
+2803
+2804
+2805
+2806
+2807
+2808
+2809
+2810
+2811
+2812
+2813
+2814
+2815
+2816
+2817
+2818
+2819
+2820
+2821
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+2831
+2832
+2833
+2834
+2835
+2836
+2837
+2838
+2839
+2840
+2841
+2842
+2843
+2844
+2845
+2846
+2847
+2848
+2849
+2850
+2851
+2852
+2853
+2854
+2855
+2856
+2857
+2858
+2859
+2860
+2861
+2862
+2863
+2864
+2865
+2866
+2867
+2868
+2869
+2870
+2871
+2872
+2873
+2874
+2875
+2876
+2877
+2878
+2879
+2880
+2881
+2882
+2883
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2894
+2895
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2913
+2914
+2915
+2916
+2917
+2918
+2919
+2920
+2921
+2922
+2923
+2924
+2925
+2926
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+2936
+2937
+2938
+2939
+2940
+2941
+2942
+2943
+2944
+2945
+2946
+2947
+2948
+2949
+2950
+2951
+2952
+2953
+2954
+2955
+2956
+2957
+2958
+2959
+2960
+2961
+2962
+2963
+2964
+2965
+2966
+2967
+2968
+2969
+2970
+2971
+2972
+2973
+2974
+2975
+2976
+2977
+2978
+2979
+2980
+2981
+2982
+2983
+2984
+2985
+2986
+2987
+2988
+2989
+2990
+2991
+2992
+2993
+2994
+2995
+2996
+2997
+2998
+2999

coral_seg/splits/val.txt

@@ -0,0 +1,450 @@
+0003
+0008
+0010
+0014
+0019
+0024
+0029
+0034
+0035
+0045
+0048
+0053
+0057
+0061
+0062
+0063
+0066
+0079
+0084
+0099
+0104
+0106
+0109
+0112
+0130
+0135
+0136
+0147
+0161
+0167
+0173
+0177
+0196
+0207
+0223
+0226
+0271
+0272
+0276
+0280
+0291
+0301
+0324
+0333
+0335
+0343
+0347
+0348
+0350
+0353
+0354
+0360
+0363
+0369
+0370
+0378
+0380
+0392
+0399
+0412
+0428
+0433
+0435
+0444
+0450
+0462
+0470
+0485
+0489
+0494
+0497
+0499
+0507
+0514
+0527
+0530
+0533
+0541
+0544
+0547
+0552
+0553
+0555
+0570
+0587
+0593
+0612
+0641
+0659
+0670
+0687
+0694
+0695
+0703
+0717
+0720
+0724
+0730
+0738
+0739
+0753
+0757
+0758
+0766
+0767
+0779
+0785
+0788
+0793
+0798
+0808
+0813
+0814
+0815
+0822
+0825
+0830
+0834
+0851
+0853
+0868
+0872
+0882
+0887
+0889
+0894
+0897
+0901
+0906
+0909
+0912
+0915
+0916
+0925
+0926
+0930
+0952
+0953
+0956
+0961
+0965
+0970
+0971
+0977
+0978
+0989
+1020
+1021
+1023
+1045
+1049
+1051
+1052
+1055
+1060
+1064
+1067
+1069
+1079
+1091
+1099
+1102
+1106
+1108
+1110
+1111
+1113
+1118
+1121
+1123
+1124
+1137
+1140
+1141
+1162
+1169
+1170
+1176
+1178
+1180
+1185
+1197
+1199
+1202
+1204
+1206
+1235
+1242
+1251
+1263
+1267
+1284
+1297
+1304
+1331
+1342
+1346
+1352
+1357
+1369
+1375
+1376
+1382
+1383
+1385
+1387
+1389
+1397
+1399
+1412
+1415
+1421
+1423
+1426
+1435
+1436
+1446
+1450
+1486
+1490
+1492
+1495
+1497
+1502
+1509
+1511
+1522
+1523
+1525
+1532
+1536
+1538
+1540
+1541
+1549
+1568
+1571
+1576
+1581
+1584
+1587
+1592
+1604
+1605
+1609
+1615
+1624
+1637
+1639
+1648
+1654
+1667
+1670
+1676
+1680
+1682
+1689
+1701
+1702
+1707
+1710
+1711
+1713
+1717
+1719
+1721
+1724
+1748
+1753
+1755
+1762
+1769
+1773
+1774
+1779
+1780
+1782
+1784
+1793
+1801
+1805
+1808
+1815
+1819
+1841
+1850
+1851
+1853
+1854
+1864
+1865
+1867
+1868
+1869
+1878
+1881
+1888
+1889
+1894
+1906
+1910
+1920
+1939
+1940
+1945
+1949
+1983
+1987
+1990
+1997
+2000
+2008
+2031
+2042
+2050
+2053
+2056
+2061
+2068
+2076
+2091
+2092
+2099
+2113
+2125
+2128
+2146
+2148
+2159
+2169
+2174
+2183
+2188
+2194
+2209
+2230
+2235
+2237
+2243
+2248
+2269
+2277
+2286
+2298
+2300
+2311
+2314
+2328
+2334
+2340
+2344
+2345
+2348
+2351
+2358
+2362
+2372
+2377
+2395
+2397
+2406
+2415
+2416
+2419
+2428
+2430
+2433
+2435
+2437
+2438
+2450
+2453
+2459
+2485
+2492
+2493
+2495
+2503
+2509
+2517
+2526
+2535
+2542
+2569
+2585
+2593
+2597
+2599
+2603
+2609
+2610
+2611
+2613
+2614
+2619
+2627
+2633
+2634
+2635
+2654
+2660
+2671
+2678
+2679
+2681
+2685
+2688
+2708
+2711
+2712
+2724
+2725
+2731
+2739
+2742
+2748
+2754
+2757
+2763
+2773
+2774
+2778
+2779
+2785
+2787
+2801
+2803
+2820
+2821
+2841
+2843
+2849
+2872
+2880
+2894
+2895
+2922
+2924
+2926
+2949
+2961
+2963
+2975
+2976
+2983
+2985
+2986
+2989
+2996
+2997

coral_seg/submissions/results.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19326a534acc1de1c4b4a901d94f11e92699cf347d3e13901f8da343a65c9502
+size 950074

coral_seg/tools/check_data.py

@@ -0,0 +1,35 @@
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.utils import list_pngs, load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    args = parser.parse_args()
+    cfg = load_config(args.config)
+    for key in ("train_images", "train_masks", "test_images"):
+        paths = list_pngs(cfg["data"][key])
+        print(key, len(paths), paths[0].name if paths else None, paths[-1].name if paths else None)
+    values = set()
+    bad = []
+    for path in list_pngs(cfg["data"]["train_masks"]):
+        arr = np.array(Image.open(path))
+        unique = set(np.unique(arr).tolist())
+        values |= unique
+        if not unique <= {0, 1, 2, 3}:
+            bad.append((path.name, sorted(unique)))
+    print("mask values:", sorted(values))
+    print("bad masks:", len(bad), bad[:5])
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/create_splits.py

@@ -0,0 +1,31 @@
+import argparse
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.splits import create_split_files
+from coral_seg.utils import load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    train_file, val_file, full_file = create_split_files(
+        cfg["data"]["train_images"],
+        cfg["data"]["train_masks"],
+        cfg["data"]["split_dir"],
+        val_ratio=float(cfg["data"].get("val_ratio", 0.15)),
+        seed=int(cfg.get("seed", 2026)),
+    )
+    print(f"train split: {train_file}")
+    print(f"val split: {val_file}")
+    print(f"full split: {full_file}")
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/download_pretrained.py

@@ -0,0 +1,54 @@
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+import torch
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from huggingface_hub import snapshot_download
+from torchvision.models import ConvNeXt_Large_Weights, convnext_large
+
+from coral_seg.utils import ensure_dir, load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    mask2former_dir = Path(cfg["mask2former"]["pretrained_dir"])
+    ensure_dir(mask2former_dir.parent)
+    has_mask2former_weight = (mask2former_dir / "model.safetensors").is_file() or (mask2former_dir / "pytorch_model.bin").is_file()
+    has_mask2former_config = (mask2former_dir / "config.json").is_file() and (mask2former_dir / "preprocessor_config.json").is_file()
+    if has_mask2former_weight and has_mask2former_config:
+        print(f"Mask2Former local files already exist: {mask2former_dir}")
+    else:
+        print("Downloading Mask2Former-Swin-B from HuggingFace cache/source...")
+        snapshot_download(
+            repo_id=cfg["mask2former"]["pretrained_name"],
+            local_dir=mask2former_dir,
+            local_dir_use_symlinks=False,
+        )
+        print(f"Mask2Former saved to {mask2former_dir}")
+
+    convnext_path = Path(cfg["convnext"].get("pretrained_path", ROOT / "pretrained/convnext_large-ea097f82.pth"))
+    ensure_dir(convnext_path.parent)
+    if convnext_path.is_file():
+        print(f"ConvNeXt-L local weight already exists: {convnext_path}")
+    else:
+        print("Downloading torchvision ConvNeXt-L ImageNet-1K weights...")
+        _ = convnext_large(weights=ConvNeXt_Large_Weights.IMAGENET1K_V1)
+        cache_name = Path(ConvNeXt_Large_Weights.IMAGENET1K_V1.url).name
+        cache_path = Path(torch.hub.get_dir()) / "checkpoints" / cache_name
+        if not cache_path.is_file():
+            raise FileNotFoundError(f"torchvision cache weight not found: {cache_path}")
+        shutil.copy2(cache_path, convnext_path)
+        print(f"ConvNeXt-L local weight saved to {convnext_path}")
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/eval_ensemble_val.py

@@ -0,0 +1,90 @@
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+from PIL import Image
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.utils import compute_iou, fast_hist, format_metrics, load_config, read_image, set_seed
+from coral_seg.splits import read_ids
+from tools.infer_ensemble import load_convnext, load_mask2former, predict_convnext, predict_mask2former
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', default=str(ROOT / 'configs/final_dual.yaml'))
+    parser.add_argument('--convnext-checkpoint', default='')
+    parser.add_argument('--mask2former-checkpoint', default='')
+    parser.add_argument('--split-file', default='')
+    parser.add_argument('--max-samples', type=int, default=0)
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    set_seed(int(cfg.get('seed', 2026)))
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    infer_cfg = cfg['infer']
+    num_classes = int(cfg['num_classes'])
+
+    conv_model = load_convnext(args.convnext_checkpoint, cfg, device) if args.convnext_checkpoint else None
+    mask_model = load_mask2former(args.mask2former_checkpoint, cfg, device) if args.mask2former_checkpoint else None
+    if conv_model is None and mask_model is None:
+        raise ValueError('Provide --convnext-checkpoint and/or --mask2former-checkpoint')
+
+    conv_w = float(infer_cfg.get('convnext_weight', 0.45)) if conv_model is not None else 0.0
+    mask_w = float(infer_cfg.get('mask2former_weight', 0.55)) if mask_model is not None else 0.0
+    norm = max(1e-6, conv_w + mask_w)
+    conv_w /= norm
+    mask_w /= norm
+    flips = list(infer_cfg.get('tta_flips', ['none']))
+
+    split_file = args.split_file or str(Path(cfg['data']['split_dir']) / 'val.txt')
+    ids = read_ids(split_file)
+    if args.max_samples > 0:
+        ids = ids[:args.max_samples]
+
+    hist = np.zeros((num_classes, num_classes), dtype=np.int64)
+    image_dir = Path(cfg['data']['train_images'])
+    mask_dir = Path(cfg['data']['train_masks'])
+
+    for idx, sample_id in enumerate(ids, start=1):
+        image_path = image_dir / f'{sample_id}.png'
+        mask_path = mask_dir / f'{sample_id}.png'
+        image = read_image(image_path)
+        target = np.array(Image.open(mask_path), dtype=np.uint8)
+        total = None
+        if conv_model is not None:
+            probs = predict_convnext(
+                conv_model,
+                image,
+                infer_cfg.get('convnext_sizes', [cfg['convnext']['image_size']]),
+                flips,
+                num_classes,
+                device,
+            )
+            total = conv_w * probs if total is None else total + conv_w * probs
+        if mask_model is not None:
+            probs = predict_mask2former(
+                mask_model,
+                image,
+                infer_cfg.get('mask2former_sizes', [cfg['mask2former']['image_size']]),
+                flips,
+                num_classes,
+                device,
+            )
+            total = mask_w * probs if total is None else total + mask_w * probs
+        pred = total.argmax(dim=1).squeeze(0).cpu().numpy().astype(np.uint8)
+        hist += fast_hist(pred, target, num_classes)
+        if idx % 50 == 0 or idx == len(ids):
+            iou, miou = compute_iou(hist)
+            print(f'evaluated {idx}/{len(ids)} {format_metrics(iou, miou, cfg["class_names"])}')
+
+    iou, miou = compute_iou(hist)
+    print('final', format_metrics(iou, miou, cfg['class_names']))
+
+
+if __name__ == '__main__':
+    main()

coral_seg/tools/eval_predictions.py

@@ -0,0 +1,99 @@
+import argparse
+from pathlib import Path
+from typing import Dict, Tuple
+
+import numpy as np
+from PIL import Image
+
+CLASS_NAMES = ['background', 'live_coral', 'dead_coral', 'bleached_coral']
+
+
+def parse_color_map(text: str) -> Dict[Tuple[int, int, int], int]:
+    mapping = {}
+    if not text:
+        return mapping
+    for item in text.split(';'):
+        item = item.strip()
+        if not item:
+            continue
+        color, label = item.split(':')
+        rgb = tuple(int(x) for x in color.split(','))
+        if len(rgb) != 3:
+            raise ValueError(f'Bad RGB color: {color}')
+        mapping[rgb] = int(label)
+    return mapping
+
+
+def read_pred(path: Path) -> np.ndarray:
+    arr = np.array(Image.open(path))
+    if arr.ndim == 3:
+        arr = arr[:, :, 0]
+    return arr.astype(np.uint8)
+
+
+def read_gt(path: Path, color_map: Dict[Tuple[int, int, int], int]) -> np.ndarray:
+    arr = np.array(Image.open(path))
+    if arr.ndim == 2:
+        return arr.astype(np.uint8)
+    if not color_map:
+        colors = np.unique(arr.reshape(-1, arr.shape[-1])[:, :3], axis=0)
+        raise ValueError(
+            'GT is RGB. Provide --color-map, for example '
+            '"0,0,0:0;0,162,232:1;240,110,170:2". '
+            f'Found colors: {colors.tolist()}'
+        )
+    rgb = arr[:, :, :3]
+    out = np.full(rgb.shape[:2], 255, dtype=np.uint8)
+    for color, label in color_map.items():
+        out[np.all(rgb == np.array(color, dtype=np.uint8), axis=-1)] = label
+    unknown = out == 255
+    if unknown.any():
+        colors = np.unique(rgb[unknown].reshape(-1, 3), axis=0)
+        raise ValueError(f'Unknown GT colors: {colors.tolist()}')
+    return out
+
+
+def fast_hist(pred: np.ndarray, target: np.ndarray, num_classes: int) -> np.ndarray:
+    pred = pred.reshape(-1)
+    target = target.reshape(-1)
+    valid = (target >= 0) & (target < num_classes)
+    hist = np.bincount(num_classes * target[valid].astype(np.int64) + pred[valid].astype(np.int64), minlength=num_classes**2)
+    return hist.reshape(num_classes, num_classes)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--pred-dir', default='/root/autodl-tmp/coral/coral_seg/submissions/results')
+    parser.add_argument('--gt-dir', required=True)
+    parser.add_argument('--color-map', default='')
+    parser.add_argument('--num-classes', type=int, default=4)
+    args = parser.parse_args()
+
+    pred_dir = Path(args.pred_dir)
+    gt_dir = Path(args.gt_dir)
+    color_map = parse_color_map(args.color_map)
+    hist = np.zeros((args.num_classes, args.num_classes), dtype=np.int64)
+    count = 0
+    for pred_path in sorted(pred_dir.glob('*.png')):
+        gt_path = gt_dir / pred_path.name
+        if not gt_path.exists():
+            continue
+        pred = read_pred(pred_path)
+        gt = read_gt(gt_path, color_map)
+        if pred.shape != gt.shape:
+            raise ValueError(f'Shape mismatch for {pred_path.name}: pred={pred.shape}, gt={gt.shape}')
+        hist += fast_hist(pred, gt, args.num_classes)
+        count += 1
+    if count == 0:
+        raise RuntimeError('No matched prediction/GT PNG files found')
+    denom = hist.sum(1) + hist.sum(0) - np.diag(hist)
+    iou = np.divide(np.diag(hist), denom, out=np.full(args.num_classes, np.nan, dtype=np.float64), where=denom != 0)
+    print('matched_files:', count)
+    print('mIoU:', float(np.nanmean(iou)))
+    for idx, value in enumerate(iou):
+        name = CLASS_NAMES[idx] if idx < len(CLASS_NAMES) else f'class_{idx}'
+        print(f'{idx} {name}: {value}')
+
+
+if __name__ == '__main__':
+    main()

coral_seg/tools/infer_ensemble.py

@@ -0,0 +1,189 @@
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from transformers import Mask2FormerForUniversalSegmentation
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.model_convnext_fpn import ConvNeXtFPN
+from coral_seg.utils import (
+    ensure_dir,
+    list_pngs,
+    load_config,
+    make_results_zip,
+    normalize_tensor,
+    read_image,
+    save_mask,
+    set_seed,
+    timestamp,
+)
+from tools.train_mask2former import semantic_logits_from_mask2former
+
+
+def apply_flip_tensor(x: torch.Tensor, flip: str) -> torch.Tensor:
+    if flip == "h":
+        return torch.flip(x, dims=[-1])
+    if flip == "v":
+        return torch.flip(x, dims=[-2])
+    if flip == "hv":
+        return torch.flip(x, dims=[-2, -1])
+    return x
+
+
+def resize_normalize(image: np.ndarray, size: int) -> torch.Tensor:
+    resized = cv2.resize(image, (size, size), interpolation=cv2.INTER_LINEAR)
+    return normalize_tensor(resized).unsqueeze(0)
+
+
+def load_convnext(checkpoint: str, cfg: Dict, device: torch.device) -> ConvNeXtFPN:
+    model = ConvNeXtFPN(num_classes=int(cfg["num_classes"]), pretrained=False)
+    ckpt = torch.load(checkpoint, map_location="cpu")
+    model.load_state_dict(ckpt["model"], strict=True)
+    return model.to(device).eval()
+
+
+def load_mask2former(path_or_ckpt: str, cfg: Dict, device: torch.device) -> Mask2FormerForUniversalSegmentation:
+    path = Path(path_or_ckpt)
+    if path.is_dir():
+        model = Mask2FormerForUniversalSegmentation.from_pretrained(path)
+    else:
+        mcfg = cfg["mask2former"]
+        base = mcfg.get("pretrained_dir") if Path(str(mcfg.get("pretrained_dir", ""))).exists() else mcfg["pretrained_name"]
+        model = Mask2FormerForUniversalSegmentation.from_pretrained(
+            base,
+            num_labels=int(cfg["num_classes"]),
+            ignore_mismatched_sizes=True,
+        )
+        ckpt = torch.load(path_or_ckpt, map_location="cpu")
+        model.load_state_dict(ckpt["model"], strict=True)
+    return model.to(device).eval()
+
+
+@torch.no_grad()
+def predict_convnext(
+    model: ConvNeXtFPN,
+    image: np.ndarray,
+    sizes: Iterable[int],
+    flips: Iterable[str],
+    num_classes: int,
+    device: torch.device,
+) -> torch.Tensor:
+    h, w = image.shape[:2]
+    probs_sum = torch.zeros((1, num_classes, h, w), device=device)
+    count = 0
+    for size in sizes:
+        x = resize_normalize(image, int(size)).to(device)
+        for flip in flips:
+            xf = apply_flip_tensor(x, flip)
+            logits = model(xf)
+            logits = apply_flip_tensor(logits, flip)
+            logits = F.interpolate(logits, size=(h, w), mode="bilinear", align_corners=False)
+            probs_sum += torch.softmax(logits, dim=1)
+            count += 1
+    return probs_sum / max(1, count)
+
+
+@torch.no_grad()
+def predict_mask2former(
+    model: Mask2FormerForUniversalSegmentation,
+    image: np.ndarray,
+    sizes: Iterable[int],
+    flips: Iterable[str],
+    num_classes: int,
+    device: torch.device,
+) -> torch.Tensor:
+    h, w = image.shape[:2]
+    probs_sum = torch.zeros((1, num_classes, h, w), device=device)
+    count = 0
+    for size in sizes:
+        x = resize_normalize(image, int(size)).to(device)
+        for flip in flips:
+            xf = apply_flip_tensor(x, flip)
+            outputs = model(pixel_values=xf)
+            logits = semantic_logits_from_mask2former(outputs, target_size=(h, w))
+            logits = apply_flip_tensor(logits, flip)
+            probs_sum += torch.softmax(logits, dim=1)
+            count += 1
+    return probs_sum / max(1, count)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    parser.add_argument("--convnext-checkpoint", default="")
+    parser.add_argument("--mask2former-checkpoint", default="")
+    parser.add_argument("--test-dir", default="")
+    parser.add_argument("--out-dir", default="")
+    parser.add_argument("--zip-path", default="")
+    parser.add_argument("--no-zip", action="store_true")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    set_seed(int(cfg.get("seed", 2026)))
+    infer_cfg = cfg["infer"]
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    test_dir = args.test_dir or cfg["data"]["test_images"]
+    out_dir = ensure_dir(args.out_dir or infer_cfg["out_dir"])
+    num_classes = int(cfg["num_classes"])
+
+    conv_model = None
+    mask_model = None
+    if args.convnext_checkpoint:
+        conv_model = load_convnext(args.convnext_checkpoint, cfg, device)
+    if args.mask2former_checkpoint:
+        mask_model = load_mask2former(args.mask2former_checkpoint, cfg, device)
+    if conv_model is None and mask_model is None:
+        raise ValueError("Provide at least one checkpoint: --convnext-checkpoint or --mask2former-checkpoint")
+
+    conv_w = float(infer_cfg.get("convnext_weight", 0.45)) if conv_model is not None else 0.0
+    mask_w = float(infer_cfg.get("mask2former_weight", 0.55)) if mask_model is not None else 0.0
+    norm = max(1e-6, conv_w + mask_w)
+    conv_w /= norm
+    mask_w /= norm
+    flips = list(infer_cfg.get("tta_flips", ["none"]))
+
+    image_paths = list_pngs(test_dir)
+    for idx, image_path in enumerate(image_paths, start=1):
+        image = read_image(image_path)
+        total = None
+        if conv_model is not None:
+            probs = predict_convnext(
+                conv_model,
+                image,
+                infer_cfg.get("convnext_sizes", [cfg["convnext"]["image_size"]]),
+                flips,
+                num_classes,
+                device,
+            )
+            total = conv_w * probs if total is None else total + conv_w * probs
+        if mask_model is not None:
+            probs = predict_mask2former(
+                mask_model,
+                image,
+                infer_cfg.get("mask2former_sizes", [cfg["mask2former"]["image_size"]]),
+                flips,
+                num_classes,
+                device,
+            )
+            total = mask_w * probs if total is None else total + mask_w * probs
+        pred = total.argmax(dim=1).squeeze(0).cpu().numpy().astype(np.uint8)
+        save_mask(out_dir / image_path.name, pred)
+        if idx % 50 == 0 or idx == len(image_paths):
+            print(f"{timestamp()} inferred {idx}/{len(image_paths)}")
+
+    if not args.no_zip:
+        zip_path = args.zip_path or infer_cfg["zip_path"]
+        make_results_zip(out_dir, zip_path)
+        print(f"saved zip: {zip_path}")
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/train_convnext.py

@@ -0,0 +1,212 @@
+import argparse
+import functools
+import sys
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.cuda.amp import GradScaler, autocast
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import LambdaLR
+from torch.utils.data import DataLoader
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.dataset import CoralSegDataset, build_train_transform, build_val_transform, segmentation_collate
+from coral_seg.losses import ComboSegLoss
+from coral_seg.model_convnext_fpn import ConvNeXtFPN
+from coral_seg.splits import create_split_files
+from coral_seg.utils import (
+    AverageMeter,
+    compute_iou,
+    cosine_warmup_lambda,
+    ensure_dir,
+    fast_hist,
+    format_metrics,
+    load_config,
+    save_json,
+    set_seed,
+    timestamp,
+)
+
+
+def build_loaders(cfg: Dict, image_size: int, batch_size: int, full_train: bool) -> tuple[DataLoader, DataLoader | None]:
+    data_cfg = cfg["data"]
+    train_file, val_file, full_file = create_split_files(
+        data_cfg["train_images"],
+        data_cfg["train_masks"],
+        data_cfg["split_dir"],
+        val_ratio=float(data_cfg.get("val_ratio", 0.15)),
+        seed=int(cfg.get("seed", 2026)),
+    )
+    split_file = full_file if full_train else train_file
+    train_ds = CoralSegDataset(
+        data_cfg["train_images"],
+        data_cfg["train_masks"],
+        str(split_file),
+        build_train_transform(image_size),
+    )
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=int(cfg["train"].get("num_workers", 8)),
+        pin_memory=True,
+        drop_last=True,
+        collate_fn=segmentation_collate,
+        persistent_workers=int(cfg["train"].get("num_workers", 8)) > 0,
+    )
+    val_loader = None
+    if not full_train:
+        val_ds = CoralSegDataset(
+            data_cfg["train_images"],
+            data_cfg["train_masks"],
+            str(val_file),
+            build_val_transform(image_size),
+        )
+        val_loader = DataLoader(
+            val_ds,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=int(cfg["train"].get("num_workers", 8)),
+            pin_memory=True,
+            collate_fn=segmentation_collate,
+            persistent_workers=int(cfg["train"].get("num_workers", 8)) > 0,
+        )
+    return train_loader, val_loader
+
+
+@torch.no_grad()
+def validate(model: torch.nn.Module, loader: DataLoader, cfg: Dict, device: torch.device) -> tuple[float, np.ndarray]:
+    model.eval()
+    num_classes = int(cfg["num_classes"])
+    hist = np.zeros((num_classes, num_classes), dtype=np.int64)
+    for batch in loader:
+        images = batch["image"].to(device, non_blocking=True)
+        masks = batch["mask"].numpy()
+        logits = model(images)
+        preds = logits.argmax(dim=1).cpu().numpy().astype(np.uint8)
+        for pred, target in zip(preds, masks):
+            hist += fast_hist(pred, target, num_classes)
+    iou, miou = compute_iou(hist)
+    return miou, iou
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    parser.add_argument("--resume", default="")
+    parser.add_argument("--full-train", action="store_true")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    set_seed(int(cfg.get("seed", 2026)))
+    conv_cfg = cfg["convnext"]
+    work_dir = ensure_dir(conv_cfg["work_dir"])
+    save_json(work_dir / "resolved_config.json", cfg)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train_loader, val_loader = build_loaders(
+        cfg,
+        image_size=int(conv_cfg["image_size"]),
+        batch_size=int(conv_cfg["batch_size"]),
+        full_train=args.full_train,
+    )
+
+    model = ConvNeXtFPN(
+        num_classes=int(cfg["num_classes"]),
+        pretrained=bool(conv_cfg.get("pretrained", True)),
+        pretrained_path=conv_cfg.get("pretrained_path"),
+    ).to(device)
+
+    if args.resume:
+        ckpt = torch.load(args.resume, map_location="cpu")
+        model.load_state_dict(ckpt["model"], strict=True)
+
+    loss_cfg = conv_cfg["loss"]
+    criterion = ComboSegLoss(
+        num_classes=int(cfg["num_classes"]),
+        ce_weight=float(loss_cfg.get("ce", 1.0)),
+        dice_weight=float(loss_cfg.get("dice", 1.0)),
+        lovasz_weight=float(loss_cfg.get("lovasz", 0.5)),
+        label_smoothing=float(loss_cfg.get("label_smoothing", 0.05)),
+    )
+
+    backbone_params = []
+    head_params = []
+    for name, param in model.named_parameters():
+        if not param.requires_grad:
+            continue
+        if name.startswith("features"):
+            backbone_params.append(param)
+        else:
+            head_params.append(param)
+
+    optimizer = AdamW(
+        [
+            {"params": backbone_params, "lr": float(conv_cfg["lr"]) * float(conv_cfg.get("backbone_lr_mult", 0.25))},
+            {"params": head_params, "lr": float(conv_cfg["lr"])},
+        ],
+        weight_decay=float(conv_cfg["weight_decay"]),
+    )
+    epochs = int(conv_cfg["epochs"])
+    total_steps = epochs * len(train_loader)
+    warmup_steps = int(conv_cfg.get("warmup_epochs", 5)) * len(train_loader)
+    scheduler = LambdaLR(
+        optimizer,
+        functools.partial(cosine_warmup_lambda, total_steps=total_steps, warmup_steps=warmup_steps),
+    )
+    scaler = GradScaler(enabled=bool(cfg["train"].get("amp", True)))
+    best_miou = -1.0
+
+    for epoch in range(1, epochs + 1):
+        model.train()
+        meter = AverageMeter()
+        for step, batch in enumerate(train_loader, start=1):
+            images = batch["image"].to(device, non_blocking=True)
+            masks = batch["mask"].to(device, non_blocking=True)
+            optimizer.zero_grad(set_to_none=True)
+            with autocast(enabled=bool(cfg["train"].get("amp", True))):
+                logits = model(images)
+                loss = criterion(logits, masks, epoch)
+            scaler.scale(loss).backward()
+            grad_clip = float(cfg["train"].get("grad_clip_norm", 0.0))
+            if grad_clip > 0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+            scaler.step(optimizer)
+            scaler.update()
+            scheduler.step()
+            meter.update(loss.item(), images.size(0))
+            if step % int(cfg["train"].get("print_freq", 50)) == 0:
+                lr = optimizer.param_groups[-1]["lr"]
+                print(f"{timestamp()} epoch={epoch}/{epochs} step={step}/{len(train_loader)} loss={meter.avg:.5f} lr={lr:.8f}")
+
+        metrics = {"epoch": epoch, "train_loss": meter.avg}
+        if val_loader is not None:
+            miou, iou = validate(model, val_loader, cfg, device)
+            metrics.update({"val_miou": miou, "val_iou": iou.tolist()})
+            print(f"{timestamp()} convnext val {format_metrics(iou, miou, cfg['class_names'])}")
+            is_best = miou > best_miou
+            best_miou = max(best_miou, miou)
+        else:
+            is_best = True
+
+        state = {
+            "model": model.state_dict(),
+            "epoch": epoch,
+            "best_miou": best_miou,
+            "config": cfg,
+            "metrics": metrics,
+        }
+        torch.save(state, work_dir / "latest.pth")
+        if is_best:
+            torch.save(state, work_dir / "best.pth")
+            print(f"{timestamp()} saved {work_dir / 'best.pth'}")
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/train_mask2former.py

@@ -0,0 +1,226 @@
+import argparse
+import functools
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.cuda.amp import GradScaler, autocast
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import LambdaLR
+from torch.utils.data import DataLoader
+from transformers import Mask2FormerForUniversalSegmentation
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from coral_seg.dataset import CoralSegDataset, build_train_transform, build_val_transform, mask2former_collate
+from coral_seg.splits import create_split_files
+from coral_seg.utils import (
+    AverageMeter,
+    compute_iou,
+    cosine_warmup_lambda,
+    ensure_dir,
+    fast_hist,
+    format_metrics,
+    load_config,
+    save_json,
+    set_seed,
+    timestamp,
+)
+
+
+def semantic_logits_from_mask2former(outputs, target_size: tuple[int, int]) -> torch.Tensor:
+    class_logits = outputs.class_queries_logits
+    mask_logits = outputs.masks_queries_logits
+    class_probs = torch.softmax(class_logits, dim=-1)[..., :-1]
+    mask_probs = torch.sigmoid(mask_logits)
+    semseg = torch.einsum("bqc,bqhw->bchw", class_probs, mask_probs)
+    return F.interpolate(semseg, size=target_size, mode="bilinear", align_corners=False)
+
+
+def build_model(cfg: Dict) -> Mask2FormerForUniversalSegmentation:
+    mcfg = cfg["mask2former"]
+    id2label = {i: name for i, name in enumerate(cfg["class_names"])}
+    label2id = {name: i for i, name in id2label.items()}
+    model_name_or_path = mcfg.get("pretrained_dir") or mcfg["pretrained_name"]
+    if not Path(str(model_name_or_path)).exists():
+        model_name_or_path = mcfg["pretrained_name"]
+    model = Mask2FormerForUniversalSegmentation.from_pretrained(
+        model_name_or_path,
+        num_labels=int(cfg["num_classes"]),
+        id2label=id2label,
+        label2id=label2id,
+        ignore_mismatched_sizes=True,
+    )
+    if bool(mcfg.get("gradient_checkpointing", True)):
+        try:
+            model.gradient_checkpointing_enable()
+        except ValueError:
+            print("Gradient checkpointing is not supported by this Mask2Former class; continuing without it.")
+    return model
+
+
+def build_loaders(cfg: Dict, image_size: int, batch_size: int, full_train: bool) -> tuple[DataLoader, DataLoader | None]:
+    data_cfg = cfg["data"]
+    train_file, val_file, full_file = create_split_files(
+        data_cfg["train_images"],
+        data_cfg["train_masks"],
+        data_cfg["split_dir"],
+        val_ratio=float(data_cfg.get("val_ratio", 0.15)),
+        seed=int(cfg.get("seed", 2026)),
+    )
+    split_file = full_file if full_train else train_file
+    collate = functools.partial(mask2former_collate, num_classes=int(cfg["num_classes"]))
+    train_ds = CoralSegDataset(
+        data_cfg["train_images"],
+        data_cfg["train_masks"],
+        str(split_file),
+        build_train_transform(image_size),
+    )
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=int(cfg["train"].get("num_workers", 8)),
+        pin_memory=True,
+        drop_last=True,
+        collate_fn=collate,
+        persistent_workers=int(cfg["train"].get("num_workers", 8)) > 0,
+    )
+    val_loader = None
+    if not full_train:
+        val_ds = CoralSegDataset(
+            data_cfg["train_images"],
+            data_cfg["train_masks"],
+            str(val_file),
+            build_val_transform(image_size),
+        )
+        val_loader = DataLoader(
+            val_ds,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=int(cfg["train"].get("num_workers", 8)),
+            pin_memory=True,
+            collate_fn=collate,
+            persistent_workers=int(cfg["train"].get("num_workers", 8)) > 0,
+        )
+    return train_loader, val_loader
+
+
+@torch.no_grad()
+def validate(model: torch.nn.Module, loader: DataLoader, cfg: Dict, device: torch.device) -> tuple[float, np.ndarray]:
+    model.eval()
+    num_classes = int(cfg["num_classes"])
+    hist = np.zeros((num_classes, num_classes), dtype=np.int64)
+    for batch in loader:
+        images = batch["image"].to(device, non_blocking=True)
+        masks = batch["raw_mask"].numpy()
+        outputs = model(pixel_values=images)
+        logits = semantic_logits_from_mask2former(outputs, target_size=masks.shape[-2:])
+        preds = logits.argmax(dim=1).cpu().numpy().astype(np.uint8)
+        for pred, target in zip(preds, masks):
+            hist += fast_hist(pred, target, num_classes)
+    iou, miou = compute_iou(hist)
+    return miou, iou
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default=str(ROOT / "configs/final_dual.yaml"))
+    parser.add_argument("--resume", default="")
+    parser.add_argument("--full-train", action="store_true")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    set_seed(int(cfg.get("seed", 2026)))
+    mcfg = cfg["mask2former"]
+    work_dir = ensure_dir(mcfg["work_dir"])
+    save_json(work_dir / "resolved_config.json", cfg)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train_loader, val_loader = build_loaders(
+        cfg,
+        image_size=int(mcfg["image_size"]),
+        batch_size=int(mcfg["batch_size"]),
+        full_train=args.full_train,
+    )
+    model = build_model(cfg).to(device)
+    if args.resume:
+        ckpt = torch.load(args.resume, map_location="cpu")
+        model.load_state_dict(ckpt["model"], strict=True)
+
+    no_decay = ("bias", "LayerNorm.weight", "layer_norm.weight", "norm.weight")
+    grouped = [
+        {
+            "params": [p for n, p in model.named_parameters() if p.requires_grad and not any(nd in n for nd in no_decay)],
+            "weight_decay": float(mcfg["weight_decay"]),
+        },
+        {
+            "params": [p for n, p in model.named_parameters() if p.requires_grad and any(nd in n for nd in no_decay)],
+            "weight_decay": 0.0,
+        },
+    ]
+    optimizer = AdamW(grouped, lr=float(mcfg["lr"]))
+    epochs = int(mcfg["epochs"])
+    total_steps = epochs * len(train_loader)
+    warmup_steps = int(mcfg.get("warmup_epochs", 5)) * len(train_loader)
+    scheduler = LambdaLR(
+        optimizer,
+        functools.partial(cosine_warmup_lambda, total_steps=total_steps, warmup_steps=warmup_steps),
+    )
+    scaler = GradScaler(enabled=bool(cfg["train"].get("amp", True)))
+    best_miou = -1.0
+
+    for epoch in range(1, epochs + 1):
+        model.train()
+        meter = AverageMeter()
+        for step, batch in enumerate(train_loader, start=1):
+            images = batch["image"].to(device, non_blocking=True)
+            mask_labels = [m.to(device, non_blocking=True) for m in batch["mask_labels"]]
+            class_labels = [c.to(device, non_blocking=True) for c in batch["class_labels"]]
+            optimizer.zero_grad(set_to_none=True)
+            with autocast(enabled=bool(cfg["train"].get("amp", True))):
+                outputs = model(pixel_values=images, mask_labels=mask_labels, class_labels=class_labels)
+                loss = outputs.loss
+            scaler.scale(loss).backward()
+            grad_clip = float(cfg["train"].get("grad_clip_norm", 0.0))
+            if grad_clip > 0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+            scaler.step(optimizer)
+            scaler.update()
+            scheduler.step()
+            meter.update(loss.item(), images.size(0))
+            if step % int(cfg["train"].get("print_freq", 50)) == 0:
+                lr = optimizer.param_groups[0]["lr"]
+                print(f"{timestamp()} epoch={epoch}/{epochs} step={step}/{len(train_loader)} loss={meter.avg:.5f} lr={lr:.8f}")
+
+        metrics = {"epoch": epoch, "train_loss": meter.avg}
+        if val_loader is not None:
+            miou, iou = validate(model, val_loader, cfg, device)
+            metrics.update({"val_miou": miou, "val_iou": iou.tolist()})
+            print(f"{timestamp()} mask2former val {format_metrics(iou, miou, cfg['class_names'])}")
+            is_best = miou > best_miou
+            best_miou = max(best_miou, miou)
+        else:
+            is_best = True
+
+        state = {
+            "model": model.state_dict(),
+            "epoch": epoch,
+            "best_miou": best_miou,
+            "config": cfg,
+            "metrics": metrics,
+        }
+        torch.save(state, work_dir / "latest.pth")
+        if is_best:
+            torch.save(state, work_dir / "best.pth")
+            model.save_pretrained(work_dir / "best_hf")
+            print(f"{timestamp()} saved {work_dir / 'best.pth'} and {work_dir / 'best_hf'}")
+
+
+if __name__ == "__main__":
+    main()

coral_seg/tools/visualize_results.py

@@ -0,0 +1,102 @@
+import argparse
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+PALETTE = np.array(
+    [
+        [0, 0, 0],
+        [0, 162, 232],
+        [240, 110, 170],
+        [255, 242, 0],
+    ],
+    dtype=np.uint8,
+)
+
+
+def label_to_color(mask: np.ndarray) -> np.ndarray:
+    mask = np.asarray(mask)
+    if mask.ndim == 3:
+        return mask.astype(np.uint8)
+    mask = np.clip(mask, 0, len(PALETTE) - 1)
+    return PALETTE[mask]
+
+
+def overlay(image: np.ndarray, color_mask: np.ndarray, alpha: float = 0.45) -> np.ndarray:
+    image = image.astype(np.float32)
+    color_mask = color_mask.astype(np.float32)
+    fg = color_mask.sum(axis=-1) > 0
+    out = image.copy()
+    out[fg] = image[fg] * (1.0 - alpha) + color_mask[fg] * alpha
+    return np.clip(out, 0, 255).astype(np.uint8)
+
+
+def add_title(arr: np.ndarray, title: str) -> np.ndarray:
+    h, w = arr.shape[:2]
+    canvas = np.full((h + 28, w, 3), 255, dtype=np.uint8)
+    canvas[28:] = arr
+    img = Image.fromarray(canvas)
+    draw = ImageDraw.Draw(img)
+    draw.text((8, 7), title, fill=(0, 0, 0))
+    return np.array(img)
+
+
+def read_rgb(path: Path) -> np.ndarray:
+    return np.array(Image.open(path).convert('RGB'))
+
+
+def read_mask(path: Path) -> np.ndarray:
+    arr = np.array(Image.open(path))
+    if arr.ndim == 3:
+        return arr[:, :, :3]
+    return arr.astype(np.uint8)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--image-dir', default='/root/autodl-tmp/coral/data_fresh/test_raw/PrecisionLabel800/images')
+    parser.add_argument('--pred-dir', default='/root/autodl-tmp/coral/coral_seg/submissions/results')
+    parser.add_argument('--gt-dir', default='')
+    parser.add_argument('--out-dir', default='/root/autodl-tmp/coral/coral_seg/vis_results')
+    parser.add_argument('--num', type=int, default=24)
+    parser.add_argument('--alpha', type=float, default=0.45)
+    args = parser.parse_args()
+
+    image_dir = Path(args.image_dir)
+    pred_dir = Path(args.pred_dir)
+    gt_dir = Path(args.gt_dir) if args.gt_dir else None
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pred_paths = sorted(pred_dir.glob('*.png'))[: args.num]
+    if not pred_paths:
+        raise RuntimeError(f'No prediction PNG files found in {pred_dir}')
+
+    for pred_path in pred_paths:
+        image_path = image_dir / pred_path.name
+        if not image_path.exists():
+            raise FileNotFoundError(image_path)
+        image = read_rgb(image_path)
+        pred = read_mask(pred_path)
+        pred_color = label_to_color(pred)
+        panels = [
+            add_title(image, 'image'),
+            add_title(pred_color, 'prediction'),
+            add_title(overlay(image, pred_color, args.alpha), 'pred overlay'),
+        ]
+        if gt_dir is not None:
+            gt_path = gt_dir / pred_path.name
+            if gt_path.exists():
+                gt = read_mask(gt_path)
+                gt_color = label_to_color(gt)
+                panels.append(add_title(gt_color, 'gt'))
+                panels.append(add_title(overlay(image, gt_color, args.alpha), 'gt overlay'))
+        canvas = np.concatenate(panels, axis=1)
+        Image.fromarray(canvas).save(out_dir / pred_path.name)
+    print(f'saved {len(pred_paths)} visualizations to {out_dir}')
+
+
+if __name__ == '__main__':
+    main()