Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies (for OpenCV)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all application files
+COPY . .
+
+# Hugging Face Spaces expose port 7860
+EXPOSE 7860
+
+# Run the FastAPI server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,76 @@
+import torch
+import cv2
+import numpy as np
+from pathlib import Path
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import tempfile
+import os
+import json
+
+from models.unet import HierarchicalUNet
+from src.inference.analyzer import SegmentationAnalyzer
+
+app = FastAPI(title="OCT Segmentation API")
+
+# Setup CORS to allow requests from the frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+checkpoint_path = Path(__file__).parent / "unet_hierarchical_best.pth"
+model = None
+
+@app.on_event("startup")
+def load_model():
+    global model
+    if checkpoint_path.exists():
+        print(f"Loading model from {checkpoint_path}...")
+        model = HierarchicalUNet(n_channels=1, n_coarse_classes=3, n_granular_classes=15)
+        checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=True)
+        model.load_state_dict(checkpoint['model_state_dict'])
+        model.to(device)
+        model.eval()
+    else:
+        print(f"Warning: Checkpoint {checkpoint_path} not found.")
+
+@app.post("/predict")
+async def predict_endpoint(file: UploadFile = File(...)):
+    if model is None:
+        raise HTTPException(status_code=500, detail="Model not loaded")
+        
+    suffix = Path(file.filename or "").suffix.lower()
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        content = await file.read()
+        tmp.write(content)
+        tmp_path = tmp.name
+        
+    try:
+        img = cv2.imread(tmp_path, cv2.IMREAD_GRAYSCALE)
+        if img is None:
+            raise HTTPException(status_code=400, detail="Invalid image file")
+            
+        img_resized = cv2.resize(img, (512, 512))
+        img_normalized = img_resized.astype(np.float32) / 255.0
+        img_tensor = torch.from_numpy(img_normalized).unsqueeze(0).unsqueeze(0).to(device)
+        
+        with torch.no_grad():
+            coarse_logits, granular_logits = model(img_tensor)
+            
+        granular_preds = torch.argmax(granular_logits, dim=1).squeeze(0).cpu().numpy()
+        
+        analyzer = SegmentationAnalyzer()
+        analysis = analyzer.analyze(granular_preds)
+        
+        # Convert to dictionary matching the JSON structure
+        return json.loads(analysis.to_json())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)

models/unet.py

@@ -0,0 +1,320 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class AttentionGate(nn.Module):
+    """
+    Attention Gate from 'Attention U-Net' (Oktay et al., 2018).
+
+    Learns a soft spatial attention mask that suppresses irrelevant background
+    activations in each skip connection, directing the decoder to focus on
+    clinically meaningful structures (thin retinal layers, small fluid pockets).
+
+    Applied on every skip connection in the decoder, so the model explicitly
+    learns *where* in the scan each layer/lesion should appear — addressing
+    the vanilla U-Net's inability to model long-range spatial dependencies.
+
+    Args:
+        F_g  : Channels in the gating signal  (upsampled decoder feature, x1).
+        F_l  : Channels in the skip connection (encoder feature, x2).
+        F_int: Intermediate channels for the attention computation (typically F_g // 2).
+    """
+
+    def __init__(self, F_g: int, F_l: int, F_int: int):
+        super().__init__()
+        # Project gating signal to F_int
+        self.W_g = nn.Sequential(
+            nn.Conv2d(F_g, F_int, kernel_size=1, bias=True),
+            nn.BatchNorm2d(F_int),
+        )
+        # Project skip connection to F_int
+        self.W_x = nn.Sequential(
+            nn.Conv2d(F_l, F_int, kernel_size=1, bias=True),
+            nn.BatchNorm2d(F_int),
+        )
+        # Scalar attention coefficient per spatial location
+        self.psi = nn.Sequential(
+            nn.Conv2d(F_int, 1, kernel_size=1, bias=True),
+            nn.BatchNorm2d(1),
+            nn.Sigmoid(),
+        )
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, g: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            g : Gating signal from the decoder path (upsampled to match x spatially).
+            x : Skip connection from the encoder path.
+        Returns:
+            Attention-weighted skip connection: x * attention_map.
+        """
+        g1 = self.W_g(g)
+        x1 = self.W_x(x)
+        psi = self.relu(g1 + x1)
+        psi = self.psi(psi)        # (B, 1, H, W) attention map in [0, 1]
+        return x * psi             # broadcast multiply across all channels
+
+
+# ---------------------------------------------------------------------------
+# Standard U-Net building blocks
+# ---------------------------------------------------------------------------
+
+class DoubleConv(nn.Module):
+    """(convolution => [BN] => ReLU) * 2"""
+
+    def __init__(self, in_channels: int, out_channels: int, mid_channels: int = None):
+        super().__init__()
+        if not mid_channels:
+            mid_channels = out_channels
+        self.double_conv = nn.Sequential(
+            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(mid_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.double_conv(x)
+
+
+class Down(nn.Module):
+    """Downscaling with maxpool then double conv"""
+
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.maxpool_conv = nn.Sequential(
+            nn.MaxPool2d(2),
+            DoubleConv(in_channels, out_channels),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.maxpool_conv(x)
+
+
+# ---------------------------------------------------------------------------
+# ASPP Bottleneck  (Fix #4 — multi-scale receptive field)
+# ---------------------------------------------------------------------------
+
+class _ASPPConv(nn.Module):
+    """Single dilated convolution branch inside ASPP."""
+
+    def __init__(self, in_channels: int, out_channels: int, dilation: int):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3,
+                      padding=dilation, dilation=dilation, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.block(x)
+
+
+class _ASPPPooling(nn.Module):
+    """Global average pooling branch inside ASPP."""
+
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.pool = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        size = x.shape[-2:]
+        pooled = self.pool(x)                                    # (B, C, 1, 1)
+        return F.interpolate(pooled, size=size,
+                             mode='bilinear', align_corners=False)  # upsample back
+
+
+class ASPP(nn.Module):
+    """
+    Atrous Spatial Pyramid Pooling (from DeepLab v3).
+
+    Runs five parallel branches over the bottleneck feature map:
+      1. 1×1 convolution            — captures pixel-level features
+      2–4. 3×3 dilated convs        — dilation rates 6, 12, 18 cover
+                                      fields of ~13, ~25, ~37 pixels at 32×32
+      5. Global average pooling     — captures the full-image context
+
+    The five outputs are concatenated and projected to `out_channels`.
+    This gives the decoder access to multi-scale context without any
+    additional spatial compression — addressing the bottleneck's tendency
+    to lose thin-layer detail through aggressive downsampling.
+
+    Args:
+        in_channels  : Input channel count (512 for down4 output).
+        out_channels : Output channel count (1024 for the decoder).
+        dilations    : Dilation rates for the three parallel atrous convs.
+    """
+
+    _MID = 256  # channels per branch; 5 × 256 = 1280 → projected to out_channels
+
+    def __init__(self, in_channels: int, out_channels: int,
+                 dilations: tuple = (6, 12, 18)):
+        super().__init__()
+        m = self._MID
+        self.branch_1x1  = nn.Sequential(
+            nn.Conv2d(in_channels, m, kernel_size=1, bias=False),
+            nn.BatchNorm2d(m),
+            nn.ReLU(inplace=True),
+        )
+        self.branch_d1   = _ASPPConv(in_channels, m, dilations[0])
+        self.branch_d2   = _ASPPConv(in_channels, m, dilations[1])
+        self.branch_d3   = _ASPPConv(in_channels, m, dilations[2])
+        self.branch_pool = _ASPPPooling(in_channels, m)
+
+        self.project = nn.Sequential(
+            nn.Conv2d(5 * m, out_channels, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Dropout2d(0.1),  # light regularisation on bottleneck features
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        branches = [
+            self.branch_1x1(x),
+            self.branch_d1(x),
+            self.branch_d2(x),
+            self.branch_d3(x),
+            self.branch_pool(x),
+        ]
+        return self.project(torch.cat(branches, dim=1))
+
+
+class BottleneckASPP(nn.Module):
+    """
+    Drop-in replacement for the deepest `Down` block.
+    Applies MaxPool2d then ASPP (instead of MaxPool2d then DoubleConv),
+    so the interface is identical: `forward(x) -> tensor`.
+    """
+
+    def __init__(self, in_channels: int, out_channels: int,
+                 dilations: tuple = (6, 12, 18)):
+        super().__init__()
+        self.maxpool = nn.MaxPool2d(2)
+        self.aspp    = ASPP(in_channels, out_channels, dilations)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.aspp(self.maxpool(x))
+
+
+class Up(nn.Module):
+    """
+    Upscaling block with an Attention Gate applied to the skip connection
+    before concatenation with the upsampled decoder feature.
+
+    Channel layout after ConvTranspose2d:
+        x1 (decoder, upsampled) : in_channels // 2
+        x2 (encoder skip)       : in_channels // 2
+    The attention gate uses x1 as the gating signal and attends x2.
+    """
+
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
+        self.attn = AttentionGate(
+            F_g=in_channels // 2,
+            F_l=in_channels // 2,
+            F_int=in_channels // 4,
+        )
+        self.conv = DoubleConv(in_channels, out_channels)
+
+    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
+        x1 = self.up(x1)
+        # Pad x1 if spatial sizes don't divide evenly
+        diffY = x2.size()[2] - x1.size()[2]
+        diffX = x2.size()[3] - x1.size()[3]
+        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
+                         diffY // 2, diffY - diffY // 2])
+        # Attend the skip connection before concatenation
+        x2 = self.attn(g=x1, x=x2)
+        x = torch.cat([x2, x1], dim=1)
+        return self.conv(x)
+
+
+# ---------------------------------------------------------------------------
+# Main Model
+# ---------------------------------------------------------------------------
+
+class HierarchicalUNet(nn.Module):
+    """
+    Hierarchical Multi-Head U-Net for retinal layer and lesion segmentation.
+
+    Architecture:
+      - Shared U-Net encoder/decoder backbone.
+      - ASPP bottleneck (Fix #4): replaces the flat DoubleConv at 32×32 with
+        Atrous Spatial Pyramid Pooling to capture multi-scale receptive fields
+        without additional spatial compression.
+      - Attention Gates on every decoder skip connection (Fix #3).
+      - Coarse Head: predicts 3 broad categories (Background, Retina, Fluid/Lesion).
+      - Granular Head: predicts 15 fine-grained classes, conditioned on the
+        coarse head's softmax probabilities — not raw logits (Fix #2).
+    """
+
+    def __init__(self, n_channels: int = 1, n_coarse_classes: int = 3, n_granular_classes: int = 15):
+        super(HierarchicalUNet, self).__init__()
+        self.n_channels = n_channels
+        self.n_coarse_classes = n_coarse_classes
+        self.n_granular_classes = n_granular_classes
+
+        # Shared Encoder
+        self.inc    = DoubleConv(n_channels, 64)
+        self.down1  = Down(64, 128)
+        self.down2  = Down(128, 256)
+        self.down3  = Down(256, 512)
+        # Bottleneck: ASPP replaces plain DoubleConv for multi-scale context
+        self.down4  = BottleneckASPP(512, 1024, dilations=(6, 12, 18))
+
+        # Shared Decoder — each Up block includes an AttentionGate on its skip connection
+        self.up1 = Up(1024, 512)
+        self.up2 = Up(512, 256)
+        self.up3 = Up(256, 128)
+        self.up4 = Up(128, 64)
+
+        # Coarse Head  →  3-channel output
+        self.coarse_conv = nn.Sequential(
+            DoubleConv(64, 64),
+            nn.Conv2d(64, n_coarse_classes, kernel_size=1),
+        )
+
+        # Granular Head  →  15-channel output
+        # Input: shared decoder features (64) + coarse softmax probabilities (n_coarse_classes)
+        self.granular_conv = nn.Sequential(
+            DoubleConv(64 + n_coarse_classes, 64),
+            nn.Conv2d(64, n_granular_classes, kernel_size=1),
+        )
+
+    def forward(self, x: torch.Tensor):
+        # ---- Encoder ----
+        x1 = self.inc(x)
+        x2 = self.down1(x1)
+        x3 = self.down2(x2)
+        x4 = self.down3(x3)
+        x5 = self.down4(x4)
+
+        # ---- Decoder (attention-gated skip connections) ----
+        x = self.up1(x5, x4)
+        x = self.up2(x,  x3)
+        x = self.up3(x,  x2)
+        shared_features = self.up4(x, x1)
+
+        # ---- Coarse Head ----
+        coarse_logits = self.coarse_conv(shared_features)
+
+        # ---- Granular Head ----
+        # FIX (Issue #2): pass softmax PROBABILITIES, not raw logits.
+        # Raw logits have arbitrary, growing scale during training — the granular
+        # DoubleConv cannot reliably interpret them as a coarse prior.
+        # Softmax maps them to a stable [0, 1] probability distribution.
+        coarse_probs = torch.softmax(coarse_logits, dim=1)
+        granular_input = torch.cat([shared_features, coarse_probs], dim=1)
+        granular_logits = self.granular_conv(granular_input)
+
+        return coarse_logits, granular_logits

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+python-multipart
+torch
+torchvision
+numpy
+opencv-python-headless
+pydantic

src/inference/analyzer.py

@@ -0,0 +1,139 @@
+import cv2
+import numpy as np
+from typing import List, Dict
+from src.inference.data_models import Point, BoundingBox, RetinalLayer, LesionInstance, ClinicalMetrics, OCTScanAnalysis
+
+class SegmentationAnalyzer:
+    """
+    Parses a dense (H, W) granular segmentation mask into an object-oriented
+    OCTScanAnalysis containing discrete vector instances and metrics.
+    """
+    
+    # Example mapping (should match your dataset's exact class labels)
+    CLASS_MAP = {
+        0: "Background",
+        1: "ILM",
+        2: "NFL-IPL",
+        3: "INL",
+        4: "OPL",
+        5: "ONL-ISM",
+        6: "ISE",
+        7: "OS-RPE",
+        8: "RPE",
+        9: "Fluid",
+        10: "Hard Drusen",
+        11: "Soft Drusen",
+        12: "PED",
+        13: "Geographic Atrophy",
+        14: "Hyper-reflective Foci"
+    }
+
+    def __init__(self, layer_classes=list(range(1, 9)), lesion_classes=list(range(9, 15))):
+        self.layer_classes = layer_classes
+        self.lesion_classes = lesion_classes
+
+    def analyze(self, mask: np.ndarray) -> OCTScanAnalysis:
+        height, width = mask.shape
+        
+        layers = self._extract_layers(mask)
+        lesions = self._extract_lesions(mask)
+        metrics = self._calculate_metrics(layers, lesions, width)
+        
+        return OCTScanAnalysis(
+            image_width=width,
+            image_height=height,
+            layers=layers,
+            lesions=lesions,
+            clinical_metrics=metrics,
+            model_version="unet_hierarchical_v1.0"
+        )
+        
+    def _extract_layers(self, mask: np.ndarray) -> List[RetinalLayer]:
+        layers = []
+        for class_id in self.layer_classes:
+            binary_mask = (mask == class_id).astype(np.uint8) * 255
+            
+            # For continuous layers, we could extract the top boundary. 
+            # A simple approach is taking the argmax along the y-axis for each x.
+            # But since layers might have gaps, contours are safer.
+            contours, _ = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            # To keep it as a simple "layer" concept for the frontend, we just take the largest contour
+            # and format it as a boundary. (Alternatively, return all contours as polygons).
+            if not contours:
+                continue
+                
+            largest_contour = max(contours, key=cv2.contourArea)
+            # Simplify contour to reduce payload size (Ramer-Douglas-Peucker)
+            epsilon = 0.001 * cv2.arcLength(largest_contour, True)
+            approx = cv2.approxPolyDP(largest_contour, epsilon, True)
+            
+            points = [Point(x=int(pt[0][0]), y=int(pt[0][1])) for pt in approx]
+            
+            # Compute average depth (mean y)
+            if points:
+                avg_depth = float(np.mean([pt.y for pt in points]))
+            else:
+                avg_depth = 0.0
+                
+            layers.append(RetinalLayer(
+                class_id=class_id,
+                class_name=self.CLASS_MAP.get(class_id, f"Layer_{class_id}"),
+                boundary_points=points,
+                avg_depth=avg_depth
+            ))
+            
+        return layers
+        
+    def _extract_lesions(self, mask: np.ndarray) -> List[LesionInstance]:
+        lesions = []
+        for class_id in self.lesion_classes:
+            binary_mask = (mask == class_id).astype(np.uint8) * 255
+            contours, _ = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            for cnt in contours:
+                area = cv2.contourArea(cnt)
+                # Filter out microscopic noise
+                if area < 5.0:
+                    continue
+                    
+                x, y, w, h = cv2.boundingRect(cnt)
+                bbox = BoundingBox(xmin=int(x), ymin=int(y), xmax=int(x+w), ymax=int(y+h))
+                
+                # Simplify polygon
+                epsilon = 0.005 * cv2.arcLength(cnt, True)
+                approx = cv2.approxPolyDP(cnt, epsilon, True)
+                polygon = [Point(x=int(pt[0][0]), y=int(pt[0][1])) for pt in approx]
+                
+                lesions.append(LesionInstance(
+                    class_id=class_id,
+                    class_name=self.CLASS_MAP.get(class_id, f"Lesion_{class_id}"),
+                    polygon=polygon,
+                    bounding_box=bbox,
+                    area_pixels=float(area),
+                    max_width=float(w),
+                    max_height=float(h)
+                ))
+        return lesions
+        
+    def _calculate_metrics(self, layers: List[RetinalLayer], lesions: List[LesionInstance], width: int) -> ClinicalMetrics:
+        # Example Metric: Total fluid area
+        fluid_area = sum([L.area_pixels for L in lesions if L.class_name == "Fluid"])
+        
+        # Example Metric: Max fluid height
+        fluid_heights = [L.max_height for L in lesions if L.class_name == "Fluid"]
+        max_fluid_h = max(fluid_heights) if fluid_heights else 0.0
+        
+        # Example Metric: Average Retinal Thickness
+        # Estimated as distance between topmost layer (ILM) and bottommost layer (RPE)
+        layer_depths = [layer.avg_depth for layer in layers]
+        if len(layer_depths) >= 2:
+            thickness = float(max(layer_depths) - min(layer_depths))
+        else:
+            thickness = 0.0
+            
+        return ClinicalMetrics(
+            average_retinal_thickness=thickness,
+            total_fluid_area=float(fluid_area),
+            max_fluid_height=float(max_fluid_h)
+        )

src/inference/data_models.py

@@ -0,0 +1,66 @@
+import json
+from dataclasses import dataclass, asdict
+from typing import List, Dict, Optional, Tuple
+
+@dataclass
+class Point:
+    x: int
+    y: int
+
+@dataclass
+class BoundingBox:
+    xmin: int
+    ymin: int
+    xmax: int
+    ymax: int
+
+@dataclass
+class RetinalLayer:
+    """
+    Represents a continuous anatomical boundary layer (e.g. ILM, RPE).
+    Stored as a sequence of points (x, y) forming a 1D spline across the image width.
+    """
+    class_id: int
+    class_name: str
+    boundary_points: List[Point]
+    avg_depth: float
+
+@dataclass
+class LesionInstance:
+    """
+    Represents a discrete pathological finding (e.g. Fluid, Drusen).
+    Stored as a closed polygon contour.
+    """
+    class_id: int
+    class_name: str
+    polygon: List[Point]
+    bounding_box: BoundingBox
+    area_pixels: float
+    # Optional clinical metrics based on geometry
+    max_height: Optional[float] = None
+    max_width: Optional[float] = None
+
+@dataclass
+class ClinicalMetrics:
+    """
+    Global clinical metrics calculated for the entire scan.
+    """
+    average_retinal_thickness: float
+    total_fluid_area: float
+    max_fluid_height: float
+
+@dataclass
+class OCTScanAnalysis:
+    """
+    The root object representing the full analysis of a single OCT B-scan.
+    """
+    image_width: int
+    image_height: int
+    layers: List[RetinalLayer]
+    lesions: List[LesionInstance]
+    clinical_metrics: ClinicalMetrics
+    model_version: str = "v1.0"
+    
+    def to_json(self) -> str:
+        """Serializes the analysis object to a JSON string."""
+        return json.dumps(asdict(self), indent=2)

src/inference/export.py

@@ -0,0 +1,22 @@
+import json
+from pathlib import Path
+from src.inference.data_models import OCTScanAnalysis
+
+class InferenceExporter:
+    @staticmethod
+    def to_json_file(analysis: OCTScanAnalysis, filepath: str) -> None:
+        """
+        Exports the OCTScanAnalysis to a JSON file.
+        """
+        out_path = Path(filepath)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(out_path, 'w') as f:
+            f.write(analysis.to_json())
+            
+    @staticmethod
+    def to_json_string(analysis: OCTScanAnalysis) -> str:
+        """
+        Exports the OCTScanAnalysis to a JSON string (for direct API responses).
+        """
+        return analysis.to_json()

unet_hierarchical_best.pth

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