SOLAR FILAMENT MODEL ARCHITECTURE モデル構成の変遷と EdgeAttNet（EG-MHSA）アーキテクチャの数理仕様

01歴代アーキテクチャの比較と変遷マトリクス

太陽フィラメント検出は、全面像（2048 × 2048 px）に対する対象領域（前景）の比率が約 0.23% と小さく、微細な線状境界の正確な抽出が求められる課題です。本プロジェクトでは、セマンティック抽出からインスタンス分離、U-Net による輪郭精密化、エッジ誘導型自己注意機構（EG-MHSA）へとモデル設計を順次検証・改良してきました。

※ コンペティション主催者は公式アナウンス（2026年8月20日）において、「PQ スコアが 0.35 を超えるモデルは学術的・実用的に大きな価値がある（Any PQ score of greater than 0.35 is of great value to us）」と述べています。第4世代 EdgeAttNet（V52）は、単一モデル構成でありながら Public LB 0.39（全Fold OOF 0.4454）を達成し、この有用性基準を満たしています。

02Instance-First 2段パイプライン全体構成

推論パイプラインは、「全体像からの個体候補検出（YOLO）」と「切り出しパッチに対する境界精密化（EdgeAttNet）」の 2 段階で構成されています。

03MediSegEdgeAttUNet の設計思想と EG-MHSA の数理構成

1. 医療画像セグメンテーション（MediSeg）手法の適用背景

医療画像解析（網膜血管や神経線維などの微小構造抽出）では、背景に対して対象領域が極めて小さく、細線構造の連続性維持が重要視されます。これは太陽フィラメントや太陽電池電極の欠陥検査における課題と数理的に共通しています。
本モデルでは、医療画像セグメンテーションで用いられるマルチスケール U-Net 構造を基盤とし、ボトルネック層にエッジ誘導型自己注意機構（EG-MHSA, arXiv:2509.02964）を組み込んだ MediSegEdgeAttUNet（約 35.2M パラメータ） を構築しました。

2. EG-MHSA（エッジ誘導自己注意）の数理メカニズム

フィラメントの境界は太陽表面の模様と類似しており、通常の Self-Attention では細い側枝（barb）や尖端が背景特徴に埋没してアテンションが拡散する傾向があります。 EG-MHSA は、入力画像から抽出した空間エッジ事前分布を Query および Key に直接加算注入することで、境界構造へのアテンション重みを適切に誘導します。

3. 境界精密化のための複合損失関数（Composite Refiner Loss）

MediSegEdgeAttUNet の学習では、極細線の境界を適切に捉えるため、領域損失（BCE ＋ SoftDice） に加えて、モルフォロジー勾配を用いた 境界差分損失（Boundary L1 Loss） を組み合わせた複合損失を採用しています。

4. 推論時における内側削り込み（shrink 演算）との結合

推論時は、YOLO11m が提案した個体候補 P と、MediSegEdgeAttUNet が出力した確率マップ \(M_{\text{prob}} \ge 0.45\) の積集合（AND 演算）を計算します：

YOLO が候補領域の大枠を特定し、MediSegEdgeAttUNet がその内側の微小境界を精査することで、過大検出を抑制しながら境界精度の向上を図っています。

04レイヤー別テンソル遷移マップ (Layer Inspector)

入力パッチ画像（320 × 320 px）が MediSegEdgeAttUNet 内を通過する際のテンソル形状遷移です。確認したいレイヤーカードをクリックすると、直下に詳細なパラメータ・演算構成・役割が表示されます。

05Fold 2 単体推論採用の工学的根拠

本プロジェクトでは、3-Fold のアンサンブルを行わず、Fold 2 単体モデル を本番推論に採用しています。これには客観的な検証データに基づく 2 つの理由があります。

• 理由 1: 後処理込みの OOF PQ スコアが 3-Fold 中で最も高い（0.4471）
  生 YOLO 単体では Fold 0 が高かったものの、U-Net による境界精密化（shrink@0.45）を通した確定スコアでは Fold 2 が +0.0521 伸び、3-Fold 中最高のスコアを記録しました。
• 理由 2: アンサンブル統合による推論遅延の排除
  3 つのモデルを多数決で統合するアンサンブルは計算時間を 3 倍消費します。Fold 2 単体に絞ることで、推論処理時間を約 1/3 に低減しつつ、検証スコア（Public LB 0.39）を維持しました。

06PyTorch コアコード実装（MediSegEdgeAttUNet）

solar_filament/models/mediseg_models.py に実装されている MediSegEdgeAttUNet、ボトルネック自己注意 EdgeGuidedMHSA、および複合損失関数 refiner_loss の実稼働コードです。

import torch
import torch.nn as nn
import torch.nn.functional as F

# ============================================================
# 1. Edge-Guided Multi-Head Self-Attention (EG-MHSA)
# ============================================================
class EdgeGuidedMHSA(nn.Module):
    """U-Net の Bottleneck でエッジ事前分布を Query/Key に注入する自己注意層"""
    def __init__(self, in_channels: int = 3, bottleneck_channels: int = 1024, num_heads: int = 8):
        super().__init__()
        # E = σ(Conv3×3(Input)): 入力パッチから空間エッジマップ (B, 1, H_in, W_in) を抽出
        self.edge_conv = nn.Conv2d(in_channels, 1, kernel_size=3, padding=1)
        # E' = Conv1×1(Interp(E)): ボトルネック解像度・チャンネル数 (B, 1024, 20, 20) へ射影
        self.edge_proj = nn.Conv2d(1, bottleneck_channels, kernel_size=1)
        self.mhsa = nn.MultiheadAttention(bottleneck_channels, num_heads, batch_first=True)
        self.norm = nn.LayerNorm(bottleneck_channels)

    def forward(self, bottleneck: torch.Tensor, original_image: torch.Tensor) -> torch.Tensor:
        b, c, h, w = bottleneck.shape
        
        # 1. エッジ事前分布の抽出とボトルネック空間への射影
        edge_map = torch.sigmoid(self.edge_conv(original_image))
        edge_map = F.interpolate(edge_map, size=(h, w), mode="bilinear", align_corners=True)
        edge_prior = self.edge_proj(edge_map)  # (B, 1024, 20, 20)

        # 2. テンソル平坦化 (B, C, H, W) ➔ (B, N, C), N = 400 トークン
        x_flat = bottleneck.flatten(2).transpose(1, 2)
        edge_flat = edge_prior.flatten(2).transpose(1, 2)
        
        # 3. Query & Key へのエッジ誘導事前分布の加算注入 (Value は元特徴量を保持)
        qk = x_flat + edge_flat
        attn_out, _ = self.mhsa(qk, qk, x_flat)

        # 4. 残差接続 ＋ LayerNorm ➔ 元の 2D テンソル形状 (B, 1024, 20, 20) へ復元
        attn_out = self.norm(attn_out + x_flat)
        return attn_out.transpose(1, 2).reshape(b, c, h, w)


# ============================================================
# 2. MediSegEdgeAttUNet 完全定義 (約 35.2M パラメータ)
# ============================================================
class DoubleConv(nn.Module):
    def __init__(self, in_ch: int, out_ch: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
        )
    def forward(self, x): return self.net(x)

class Down(nn.Module):
    def __init__(self, in_ch: int, out_ch: int):
        super().__init__()
        self.net = nn.Sequential(nn.MaxPool2d(2), DoubleConv(in_ch, out_ch))
    def forward(self, x): return self.net(x)

class Up(nn.Module):
    def __init__(self, in_ch: int, out_ch: int):
        super().__init__()
        self.up = nn.ConvTranspose2d(in_ch, in_ch // 2, kernel_size=2, stride=2)
        self.conv = DoubleConv(in_ch, out_ch)
    def forward(self, x1, x2):
        x1 = self.up(x1)
        x = torch.cat([x2, x1], dim=1)
        return self.conv(x)

class MediSegEdgeAttUNet(nn.Module):
    """MediSeg-AI のマルチスケール U-Net 骨格に EG-MHSA を融合した精密化モデル"""
    def __init__(self, in_channels: int = 3, out_channels: int = 1, num_heads: int = 8):
        super().__init__()
        self.inc = DoubleConv(in_channels, 64)
        self.down1 = Down(64, 128)
        self.down2 = Down(128, 256)
        self.down3 = Down(256, 512)
        self.down4 = Down(512, 1024)
        
        # ボトルネック注意層
        self.edge_attn = EdgeGuidedMHSA(in_channels, bottleneck_channels=1024, num_heads=num_heads)
        
        self.up1 = Up(1024, 512)
        self.up2 = Up(512, 256)
        self.up3 = Up(256, 128)
        self.up4 = Up(128, 64)
        self.outc = nn.Conv2d(64, out_channels, kernel_size=1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Encoder
        x1 = self.inc(x)         # [B, 64, 320, 320]
        x2 = self.down1(x1)      # [B, 128, 160, 160]
        x3 = self.down2(x2)      # [B, 256, 80, 80]
        x4 = self.down3(x3)      # [B, 512, 40, 40]
        x5 = self.down4(x4)      # [B, 1024, 20, 20]
        
        # EG-MHSA Attention (元画像 x を参照してエッジ注入)
        x5 = self.edge_attn(x5, x)

        # Decoder with Skip Connections
        out = self.up1(x5, x4)   # [B, 512, 40, 40]
        out = self.up2(out, x3)  # [B, 256, 80, 80]
        out = self.up3(out, x2)  # [B, 128, 160, 160]
        out = self.up4(out, x1)  # [B, 64, 320, 320]
        return self.outc(out)    # [B, 1, 320, 320] Logits


# ============================================================
# 3. 複合損失関数 (Composite Refiner Loss)
# ============================================================
def boundary_map(tensor: torch.Tensor) -> torch.Tensor:
    """微分可能なモルフォロジー演算（膨張 - 収縮）により輪郭境界 (2〜3px) を抽出"""
    dilation = F.max_pool2d(tensor, kernel_size=5, stride=1, padding=2)
    erosion = -F.max_pool2d(-tensor, kernel_size=5, stride=1, padding=2)
    return torch.clamp(dilation - erosion, 0.0, 1.0)

def soft_dice_loss(logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
    probs = torch.sigmoid(logits)
    intersection = (probs * targets).sum((1, 2, 3))
    denominator = probs.sum((1, 2, 3)) + targets.sum((1, 2, 3))
    return (1.0 - (2.0 * intersection + 1.0) / (denominator + 1.0)).mean()

def refiner_loss(logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
    bce = F.binary_cross_entropy_with_logits(logits, targets)
    dice = soft_dice_loss(logits, targets)
    edge_l1 = F.l1_loss(boundary_map(torch.sigmoid(logits)), boundary_map(targets))
    return 0.35 * bce + 0.65 * dice + 0.15 * edge_l1

07科学・実運用への展開 — 宇宙天気と太陽電池（PV）検査

微細な線状構造を抽出する本アーキテクチャ（EG-MHSA）は、宇宙物理観測および産業検査の双方において実用的な応用が期待されます。