1treg = (timestep / 1000)^5

 1# 1. 建立虛擬環境（使用 uv，符合 AIKT 規範）
 2uv venv .venv --python 3.10
 3source .venv/bin/activate
 4
 5# 2. Clone repository
 6git clone https://github.com/naver-ai/DenseDiffusion.git
 7cd DenseDiffusion
 8
 9# 3. 安裝依賴（注意版本鎖定）
10uv pip install -r requirements.txt
11
12# requirements.txt 內容：
13# diffusers==0.20.2
14# transformers==4.28.0
15# gradio==3.43.2
16# accelerate

1# 方式一：環境變數
2export HF_TOKEN="hf_xxxxxxxxxxxxxxxxxxxxxxxx"
3
4# 方式二：修改 gradio_app.py 第 77 行
5# HF_TOKEN = 'hf_xxxxxxxxxxxxxxxxxxxxxxxx'
6
7# 方式三：huggingface-cli 登入（推薦）
8huggingface-cli login

1python gradio_app.py
2# 預設啟動於 http://0.0.0.0:7860

 1# gradio_app.py 已包含完整流程，直接啟動即可
 2# python gradio_app.py
 3
 4# 四步驟操作流程：
 5# Step 1: 在 canvas 上用不同顏色繪製佈局
 6# Step 2: 為每個顏色區段（segment）輸入文字描述
 7# Step 3: 調整全局描述文字（預設為各 segment 文字的串接）
 8# Step 4: 調整超參數並生成
 9
10# 超參數建議：
11# - w^c (creg) = 1.0：標準文字-區域對齊
12# - w^s (sreg) = 0.3：適度的區域隔離
13# - sizereg = 1.0：完全啟用面積自適應

 1"""
 2DenseDiffusion 程式化批次生成範例
 3適用場景：批次合成具有指定組織佈局的病理影像
 4"""
 5import torch
 6import numpy as np
 7from PIL import Image
 8import torch.nn.functional as F
 9import diffusers
10from diffusers import DDIMScheduler
11
12# ---- 載入模型 ----
13device = "cuda"
14pipe = diffusers.StableDiffusionPipeline.from_pretrained(
15    "runwayml/stable-diffusion-v1-5",
16    variant="fp16",
17    torch_dtype=torch.float16,
18).to(device)
19pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
20pipe.scheduler.set_timesteps(50)
21sp_sz = pipe.unet.sample_size  # 通常為 64
22
23# ---- 定義佈局與描述 ----
24# 模擬一個簡化的組織佈局：
25#   - 背景（白色）: 正常組織
26#   - 區域 1（左半）: 染色較深的區域
27#   - 區域 2（右半）: 染色較淺的區域
28
29def create_rectangular_masks(h, w):
30    """建立簡易矩形佈局遮罩"""
31    bg_mask = np.ones((h, w), dtype=np.float32)
32    region1 = np.zeros((h, w), dtype=np.float32)
33    region2 = np.zeros((h, w), dtype=np.float32)
34
35    # 左半部分為區域 1
36    region1[:, :w//2] = 1.0
37    # 右半部分為區域 2
38    region2[:, w//2:] = 1.0
39    # 背景為兩個區域的補集
40    bg_mask = 1.0 - np.clip(region1 + region2, 0, 1)
41
42    return [bg_mask, region1, region2]
43
44masks = create_rectangular_masks(512, 512)
45prompts = [
46    "a high resolution microscopy image of tissue",   # master prompt
47    "background with uniform pink staining",           # bg segment
48    "densely packed dark purple nuclei cluster",        # region 1
49    "sparse pale eosinophilic cytoplasm region",        # region 2
50]
51
52# ---- 前處理遮罩 ----
53def preprocess_mask(mask_np, h, w, dev):
54    mask = torch.from_numpy(mask_np).float().unsqueeze(0).unsqueeze(0).to(dev)
55    mask = F.interpolate(mask, size=(h, w), mode='nearest')
56    return mask
57
58layouts = torch.cat([
59    preprocess_mask(m, sp_sz, sp_sz, device) for m in masks
60])
61
62# ---- 建立調控圖 (與 gradio_app.py 邏輯一致) ----
63sreg_maps = {}
64reg_sizes = {}
65sizereg_val = 1.0
66
67for r in range(4):
68    res = int(sp_sz / np.power(2, r))
69    layouts_s = F.interpolate(layouts, (res, res), mode='nearest')
70    layouts_s = (
71        layouts_s.view(layouts_s.size(0), 1, -1)
72        * layouts_s.view(layouts_s.size(0), -1, 1)
73    ).sum(0).unsqueeze(0)
74    reg_sizes[int(np.power(res, 2))] = (
75        1 - sizereg_val * layouts_s.sum(-1, keepdim=True) / np.power(res, 2)
76    )
77    sreg_maps[int(np.power(res, 2))] = layouts_s
78
79print(f"已建立 {len(sreg_maps)} 個解析度的 self-attention 調控圖")
80print(f"解析度: {list(sreg_maps.keys())}")
81# 輸出: 解析度: [4096, 1024, 256, 64]

 1"""
 2評估生成影像的佈局精確度
 3對應 repo 中的 eval_iou.ipynb
 4"""
 5import torch
 6import numpy as np
 7
 8def compute_layout_iou(attention_maps: dict, target_masks: list,
 9                       resolution: int = 64) -> dict:
10    """
11    計算 cross-attention map 與目標 layout mask 之間的 IoU
12
13    Parameters
14    ----------
15    attention_maps : dict
16        從 UNet 中間層提取的 cross-attention maps
17        key = spatial_resolution^2, value = tensor [B, H*W, 77]
18    target_masks : list[np.ndarray]
19        每個 segment 的目標 binary mask
20    resolution : int
21        評估的空間解析度
22
23    Returns
24    -------
25    dict
26        包含每個 segment 的 IoU 分數與整體平均
27    """
28    results = {}
29    ious = []
30
31    for seg_idx, mask in enumerate(target_masks):
32        # 將目標 mask resize 到評估解析度
33        mask_tensor = torch.from_numpy(mask).float().unsqueeze(0).unsqueeze(0)
34        mask_resized = torch.nn.functional.interpolate(
35            mask_tensor, size=(resolution, resolution), mode='nearest'
36        ).squeeze().flatten()
37
38        # 從 attention map 提取對應 token 的空間分佈
39        attn_key = resolution * resolution
40        if attn_key in attention_maps:
41            attn = attention_maps[attn_key]  # [B, H*W, 77]
42            # 取該 segment 對應 token 範圍的最大 attention
43            seg_attn = attn[0, :, seg_idx].detach().cpu()
44
45            # 二值化 attention map (Otsu threshold 或簡單閾值)
46            threshold = seg_attn.mean()
47            attn_binary = (seg_attn > threshold).float()
48
49            # 計算 IoU
50            intersection = (attn_binary * mask_resized).sum()
51            union = ((attn_binary + mask_resized) > 0).float().sum()
52            iou = (intersection / (union + 1e-8)).item()
53
54            results[f"segment_{seg_idx}"] = {
55                "iou": round(iou, 4),
56                "mask_coverage": round(mask_resized.sum().item()
57                                       / mask_resized.numel(), 4),
58            }
59            ious.append(iou)
60
61    results["mean_iou"] = round(np.mean(ious), 4) if ious else 0.0
62    return results
63
64# 使用範例
65# target_masks = [bg_mask, tumor_mask, stroma_mask]
66# iou_results = compute_layout_iou(attention_maps, target_masks)
67# print(f"平均 IoU: {iou_results['mean_iou']}")

 1# 概念流程：使用 MONAI 的 segmentation 輸出作為 DenseDiffusion 的佈局輸入
 2
 3# Step 1: MONAI 語義分割 → 產出多類別 mask
 4# Step 2: 將 MONAI mask 轉換為 DenseDiffusion 的 binary_matrixes 格式
 5# Step 3: 為每個類別撰寫描述性 prompt
 6# Step 4: 使用 DenseDiffusion 生成合成影像
 7
 8def monai_masks_to_dense_layout(segmentation_output, class_names):
 9    """
10    將 MONAI segmentation 輸出轉換為 DenseDiffusion 格式
11
12    Parameters
13    ----------
14    segmentation_output : np.ndarray
15        shape (H, W)，每個 pixel 的值代表類別 index
16    class_names : list[str]
17        每個類別的文字描述
18
19    Returns
20    -------
21    binary_matrixes : list[np.ndarray]
22        每個類別的 binary mask
23    prompts : list[str]
24        segment 描述列表
25    """
26    binary_matrixes = []
27    prompts = []
28
29    unique_classes = np.unique(segmentation_output)
30    for cls_idx in unique_classes:
31        mask = (segmentation_output == cls_idx).astype(np.float32)
32        binary_matrixes.append(mask)
33        if cls_idx < len(class_names):
34            prompts.append(class_names[cls_idx])
35
36    return binary_matrixes, prompts

 1# 概念整合：將 DenseDiffusion 包裝為 medigan 相容的 generator
 2
 3# medigan 標準介面
 4# generators.generate(model_id="dense_diffusion_pathology",
 5#                     layout=layout_masks,
 6#                     prompts=segment_prompts)
 7
 8# DenseDiffusion 提供的獨特功能：
 9# - 佈局導向的條件生成（其他 medigan generator 通常不支援）
10# - 免訓練，可快速適配新的描述詞彙
11# - 透過 prompt engineering 適配不同的醫學影像 domain

 1DenseDiffusion/
 2├── gradio_app.py          # 主程式：Gradio 介面 + UNet attention monkey-patch
 3├── utils.py               # 工具函式：mask 前處理、sketch/prompt 處理
 4├── inference.ipynb         # 推論範例 Notebook
 5├── eval_iou.ipynb          # IoU 評估 Notebook
 6├── requirements.txt        # 依賴鎖定（diffusers==0.20.2）
 7├── dataset/
 8│   ├── valset.pkl          # 驗證集 prompt metadata
 9│   ├── valset_layout.tar.gz   # 驗證集佈局影像
10│   ├── testset.pkl         # 測試集 prompt metadata
11│   ├── testset_instances.pkl  # 測試集 instance metadata
12│   └── testset_layout.tar.gz  # 測試集佈局影像
13├── figures/                # README 用的說明圖
14├── LICENSE                 # Apache-2.0
15└── NOTICE                  # 第三方授權聲明