Doul0414 commited on Jan 5

Commit

343e05c

verified ·

1 Parent(s): facde7c

Initial upload: HintsPrediction

Browse files

Files changed (18) hide show

README.md +113 -0
checkpoints/checkpoint_best.pth +3 -0
classification_test_set_single.json +0 -0
classification_val_set_single.json +1688 -0
config.yaml +48 -0
evaluate.py +236 -0
infer_single_case.py +244 -0
models/__init__.py +13 -0
models/aslloss.py +115 -0
models/transformer.py +374 -0
models/transmil_q2l.py +589 -0
requirements.txt +12 -0
scripts/evaluate.sh +6 -0
scripts/infer_single.sh +7 -0
scripts/train.sh +5 -0
thyroid_dataset.py +285 -0
thyroid_multilabel_annotations.csv +0 -0
train_hybrid.py +439 -0

README.md ADDED Viewed

	@@ -0,0 +1,113 @@

+# 超声提示多标签分类模型
+基于 **TransMIL + Query2Label** 混合架构的甲状腺超声图像多标签分类模型。
+## 模型架构
+- **Backbone**: ResNet-50 (预训练)
+- **特征聚合**: TransMIL (Nystrom Attention)
+- **多标签分类**: Query2Label (Transformer Decoder)
+- **损失函数**: Asymmetric Loss (处理类别不平衡)
+## 17类标签
+| 序号 | 标签 | 序号 | 标签 |
+|:---:|:---|:---:|:---|
+| 1 | TI-RADS 1级 | 10 | 囊肿 |
+| 2 | TI-RADS 2级 | 11 | 淋巴结 |
+| 3 | TI-RADS 3级 | 12 | 胶质潴留 |
+| 4 | TI-RADS 4a级 | 13 | 弥漫性病变 |
+| 5 | TI-RADS 4b级 | 14 | 结节性甲状腺肿 |
+| 6 | TI-RADS 4c级 | 15 | 桥本氏甲状腺炎 |
+| 7 | TI-RADS 5级 | 16 | 反应性 |
+| 8 | 钙化 | 17 | 转移性 |
+| 9 | 甲亢 | | |
+## 目录结构
+```
+HintsPrediction/
+├── README.md                 # 本文件
+├── requirements.txt          # 依赖列表
+├── config.yaml               # 配置文件（需修改路径）
+├── models/                   # 模型代码
+│   ├── __init__.py
+│   ├── transmil_q2l.py       # 主模型架构
+│   ├── transformer.py        # Transformer 组件
+│   └── aslloss.py            # 损失函数
+├── checkpoints/
+│   └── checkpoint_best.pth   # 最佳模型权重
+├── scripts/                  # 懒人脚本
+│   ├── train.sh
+│   ├── evaluate.sh
+│   └── infer_single.sh
+├── train_hybrid.py           # 训练代码
+├── evaluate.py               # 评估代码
+├── thyroid_dataset.py        # 数据集加载
+└── infer_single_case.py      # 单步推理代码
+```
+## 快速开始
+### 1. 环境配置
+```bash
+# 安装依赖
+pip install -r requirements.txt
+```
+### 2. 单步推理
+```bash
+用法:
+    # 指定多个图像文件
+    python infer_single_case.py --images /path/to/img1.png /path/to/img2.png --threshold 0.5
+    # 指定图像文件夹
+    python infer_single_case.py --image_dir /path/to/case_folder/ --threshold 0.5
+# 或使用脚本
+用法1: bash scripts/infer_single.sh /path/to/image1.png /path/to/image2.png ...
+用法2: bash scripts/infer_single.sh --image_dir /path/to/case_folder/
+```
+### 3. 评估模型
+```bash
+# 先修改 config.yaml 中的数据路径
+# 然后运行评估
+python evaluate.py
+# 或
+bash scripts/evaluate.sh
+```
+### 4. 训练模型
+```bash
+# 先修改 config.yaml 中的数据路径
+python train_hybrid.py --config config.yaml
+# 或
+bash scripts/train.sh
+```
+## 配置说明
+使用前请修改 `config.yaml` 中的数据路径：
+```yaml
+data:
+  data_root: "/path/to/your/ReportData_ROI/"
+  annotation_csv: "/path/to/your/thyroid_multilabel_annotations.csv"
+  val_json: "/path/to/your/classification_val_set_single.json"
+  test_json: "/path/to/your/classification_test_set_single.json"
+```
+## 性能指标
+在测试集上的性能（请参考 `checkpoints/evaluation_report.csv`）
+## 注意事项
+1. 推理时需要 GPU（推荐），CPU 也可运行但较慢
+2. 单病例可输入多张图像，模型会自动聚合特征
+3. 默认阈值为 0.5，可根据需要调整

checkpoints/checkpoint_best.pth ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:fcbcfb29005eaf6d02bcb8c94be860d885f6fecf9cdcea40be38e7d96050f44b
+size 416241673

classification_test_set_single.json ADDED Viewed

The diff for this file is too large to render. See raw diff

classification_val_set_single.json ADDED Viewed

	@@ -0,0 +1,1688 @@

+[
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P323",
+    "rel_path": "Batch10/20250506_P323",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P424",
+    "rel_path": "Batch10/20250506_P424",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P199",
+    "rel_path": "Batch10/20250504_P199",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P829",
+    "rel_path": "Batch10/20250508_P829",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P34",
+    "rel_path": "Batch10/20250501_P34",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1380",
+    "rel_path": "Batch10/20250512_P1380",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P405",
+    "rel_path": "Batch10/20250506_P405",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P48",
+    "rel_path": "Batch10/20250502_P48",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1172",
+    "rel_path": "Batch10/20250510_P1172",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P119",
+    "rel_path": "Batch10/20250504_P119",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P140",
+    "rel_path": "Batch10/20250504_P140",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1013",
+    "rel_path": "Batch10/20250509_P1013",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P727",
+    "rel_path": "Batch10/20250508_P727",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P656",
+    "rel_path": "Batch10/20250507_P656",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P720",
+    "rel_path": "Batch10/20250508_P720",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P647",
+    "rel_path": "Batch10/20250507_P647",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1122",
+    "rel_path": "Batch10/20250510_P1122",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1182",
+    "rel_path": "Batch10/20250510_P1182",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P40",
+    "rel_path": "Batch10/20250501_P40",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P254",
+    "rel_path": "Batch10/20250505_P254",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P810",
+    "rel_path": "Batch10/20250508_P810",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P636",
+    "rel_path": "Batch10/20250507_P636",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P557",
+    "rel_path": "Batch10/20250507_P557",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1272",
+    "rel_path": "Batch10/20250512_P1272",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1306",
+    "rel_path": "Batch10/20250512_P1306",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P311",
+    "rel_path": "Batch10/20250506_P311",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P258",
+    "rel_path": "Batch10/20250505_P258",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P25",
+    "rel_path": "Batch10/20250501_P25",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1273",
+    "rel_path": "Batch10/20250512_P1273",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1277",
+    "rel_path": "Batch10/20250512_P1277",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P350",
+    "rel_path": "Batch10/20250506_P350",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1289",
+    "rel_path": "Batch10/20250512_P1289",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1386",
+    "rel_path": "Batch10/20250512_P1386",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P933",
+    "rel_path": "Batch10/20250509_P933",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P842",
+    "rel_path": "Batch10/20250508_P842",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P974",
+    "rel_path": "Batch10/20250509_P974",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1235",
+    "rel_path": "Batch10/20250511_P1235",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P28",
+    "rel_path": "Batch10/20250501_P28",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1230",
+    "rel_path": "Batch10/20250511_P1230",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P279",
+    "rel_path": "Batch10/20250505_P279",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1228",
+    "rel_path": "Batch10/20250511_P1228",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P351",
+    "rel_path": "Batch10/20250506_P351",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P195",
+    "rel_path": "Batch10/20250504_P195",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P825",
+    "rel_path": "Batch10/20250508_P825",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P596",
+    "rel_path": "Batch10/20250507_P596",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P539",
+    "rel_path": "Batch10/20250507_P539",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1333",
+    "rel_path": "Batch10/20250512_P1333",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P706",
+    "rel_path": "Batch10/20250508_P706",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P902",
+    "rel_path": "Batch10/20250509_P902",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1303",
+    "rel_path": "Batch10/20250512_P1303",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P913",
+    "rel_path": "Batch10/20250509_P913",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P300",
+    "rel_path": "Batch10/20250506_P300",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P66",
+    "rel_path": "Batch10/20250502_P66",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P726",
+    "rel_path": "Batch10/20250508_P726",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P222",
+    "rel_path": "Batch10/20250505_P222",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1165",
+    "rel_path": "Batch10/20250510_P1165",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P348",
+    "rel_path": "Batch10/20250506_P348",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P678",
+    "rel_path": "Batch10/20250507_P678",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P169",
+    "rel_path": "Batch10/20250504_P169",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P473",
+    "rel_path": "Batch10/20250506_P473",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P427",
+    "rel_path": "Batch10/20250506_P427",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P711",
+    "rel_path": "Batch10/20250508_P711",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P738",
+    "rel_path": "Batch10/20250508_P738",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P655",
+    "rel_path": "Batch10/20250507_P655",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P765",
+    "rel_path": "Batch10/20250508_P765",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P658",
+    "rel_path": "Batch10/20250507_P658",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1109",
+    "rel_path": "Batch10/20250510_P1109",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P629",
+    "rel_path": "Batch10/20250507_P629",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1377",
+    "rel_path": "Batch10/20250512_P1377",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1401",
+    "rel_path": "Batch10/20250512_P1401",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P62",
+    "rel_path": "Batch10/20250502_P62",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P659",
+    "rel_path": "Batch10/20250507_P659",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P275",
+    "rel_path": "Batch10/20250505_P275",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P21",
+    "rel_path": "Batch10/20250501_P21",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1412",
+    "rel_path": "Batch10/20250512_P1412",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P514",
+    "rel_path": "Batch10/20250507_P514",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P179",
+    "rel_path": "Batch10/20250504_P179",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P188",
+    "rel_path": "Batch10/20250504_P188",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1249",
+    "rel_path": "Batch10/20250512_P1249",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1069",
+    "rel_path": "Batch10/20250509_P1069",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1391",
+    "rel_path": "Batch10/20250512_P1391",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P480",
+    "rel_path": "Batch10/20250506_P480",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P167",
+    "rel_path": "Batch10/20250504_P167",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P74",
+    "rel_path": "Batch10/20250503_P74",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P223",
+    "rel_path": "Batch10/20250505_P223",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P833",
+    "rel_path": "Batch10/20250508_P833",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1336",
+    "rel_path": "Batch10/20250512_P1336",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P775",
+    "rel_path": "Batch10/20250508_P775",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P553",
+    "rel_path": "Batch10/20250507_P553",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P59",
+    "rel_path": "Batch10/20250502_P59",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1295",
+    "rel_path": "Batch10/20250512_P1295",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P220",
+    "rel_path": "Batch10/20250505_P220",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P77",
+    "rel_path": "Batch10/20250503_P77",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1231",
+    "rel_path": "Batch10/20250511_P1231",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P389",
+    "rel_path": "Batch10/20250506_P389",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P573",
+    "rel_path": "Batch10/20250507_P573",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P385",
+    "rel_path": "Batch10/20250506_P385",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P782",
+    "rel_path": "Batch10/20250508_P782",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P851",
+    "rel_path": "Batch10/20250508_P851",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P481",
+    "rel_path": "Batch10/20250506_P481",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1243",
+    "rel_path": "Batch10/20250511_P1243",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P956",
+    "rel_path": "Batch10/20250509_P956",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P341",
+    "rel_path": "Batch10/20250506_P341",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P752",
+    "rel_path": "Batch10/20250508_P752",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P861",
+    "rel_path": "Batch10/20250509_P861",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1320",
+    "rel_path": "Batch10/20250512_P1320",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P12",
+    "rel_path": "Batch10/20250501_P12",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1312",
+    "rel_path": "Batch10/20250512_P1312",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P588",
+    "rel_path": "Batch10/20250507_P588",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P904",
+    "rel_path": "Batch10/20250509_P904",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1370",
+    "rel_path": "Batch10/20250512_P1370",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P565",
+    "rel_path": "Batch10/20250507_P565",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P412",
+    "rel_path": "Batch10/20250506_P412",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P267",
+    "rel_path": "Batch10/20250505_P267",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P849",
+    "rel_path": "Batch10/20250508_P849",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P921",
+    "rel_path": "Batch10/20250509_P921",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P257",
+    "rel_path": "Batch10/20250505_P257",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1242",
+    "rel_path": "Batch10/20250511_P1242",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P453",
+    "rel_path": "Batch10/20250506_P453",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P892",
+    "rel_path": "Batch10/20250509_P892",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P116",
+    "rel_path": "Batch10/20250504_P116",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P531",
+    "rel_path": "Batch10/20250507_P531",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P98",
+    "rel_path": "Batch10/20250503_P98",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P926",
+    "rel_path": "Batch10/20250509_P926",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1119",
+    "rel_path": "Batch10/20250510_P1119",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P240",
+    "rel_path": "Batch10/20250505_P240",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P129",
+    "rel_path": "Batch10/20250504_P129",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P710",
+    "rel_path": "Batch10/20250508_P710",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1220",
+    "rel_path": "Batch10/20250511_P1220",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P103",
+    "rel_path": "Batch10/20250503_P103",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P878",
+    "rel_path": "Batch10/20250509_P878",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P172",
+    "rel_path": "Batch10/20250504_P172",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1318",
+    "rel_path": "Batch10/20250512_P1318",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P530",
+    "rel_path": "Batch10/20250507_P530",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1247",
+    "rel_path": "Batch10/20250511_P1247",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P677",
+    "rel_path": "Batch10/20250507_P677",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P694",
+    "rel_path": "Batch10/20250508_P694",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P246",
+    "rel_path": "Batch10/20250505_P246",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1339",
+    "rel_path": "Batch10/20250512_P1339",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P666",
+    "rel_path": "Batch10/20250507_P666",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P433",
+    "rel_path": "Batch10/20250506_P433",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P467",
+    "rel_path": "Batch10/20250506_P467",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P451",
+    "rel_path": "Batch10/20250506_P451",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P552",
+    "rel_path": "Batch10/20250507_P552",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P431",
+    "rel_path": "Batch10/20250506_P431",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P291",
+    "rel_path": "Batch10/20250506_P291",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P987",
+    "rel_path": "Batch10/20250509_P987",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1198",
+    "rel_path": "Batch10/20250510_P1198",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1040",
+    "rel_path": "Batch10/20250509_P1040",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P483",
+    "rel_path": "Batch10/20250506_P483",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P183",
+    "rel_path": "Batch10/20250504_P183",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P569",
+    "rel_path": "Batch10/20250507_P569",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P485",
+    "rel_path": "Batch10/20250506_P485",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P363",
+    "rel_path": "Batch10/20250506_P363",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P945",
+    "rel_path": "Batch10/20250509_P945",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1161",
+    "rel_path": "Batch10/20250510_P1161",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P976",
+    "rel_path": "Batch10/20250509_P976",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P809",
+    "rel_path": "Batch10/20250508_P809",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P489",
+    "rel_path": "Batch10/20250506_P489",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P687",
+    "rel_path": "Batch10/20250508_P687",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P603",
+    "rel_path": "Batch10/20250507_P603",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P69",
+    "rel_path": "Batch10/20250502_P69",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1062",
+    "rel_path": "Batch10/20250509_P1062",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P306",
+    "rel_path": "Batch10/20250506_P306",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P543",
+    "rel_path": "Batch10/20250507_P543",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P623",
+    "rel_path": "Batch10/20250507_P623",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P395",
+    "rel_path": "Batch10/20250506_P395",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P795",
+    "rel_path": "Batch10/20250508_P795",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P857",
+    "rel_path": "Batch10/20250509_P857",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P106",
+    "rel_path": "Batch10/20250503_P106",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P512",
+    "rel_path": "Batch10/20250506_P512",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1507",
+    "rel_path": "Batch10/20250512_P1507",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1459",
+    "rel_path": "Batch10/20250512_P1459",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P682",
+    "rel_path": "Batch10/20250507_P682",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P764",
+    "rel_path": "Batch10/20250508_P764",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P57",
+    "rel_path": "Batch10/20250502_P57",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1189",
+    "rel_path": "Batch10/20250510_P1189",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P321",
+    "rel_path": "Batch10/20250506_P321",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1225",
+    "rel_path": "Batch10/20250511_P1225",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P838",
+    "rel_path": "Batch10/20250508_P838",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P58",
+    "rel_path": "Batch10/20250502_P58",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1245",
+    "rel_path": "Batch10/20250511_P1245",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P35",
+    "rel_path": "Batch10/20250501_P35",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P196",
+    "rel_path": "Batch10/20250504_P196",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1497",
+    "rel_path": "Batch10/20250512_P1497",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P816",
+    "rel_path": "Batch10/20250508_P816",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1420",
+    "rel_path": "Batch10/20250512_P1420",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P286",
+    "rel_path": "Batch10/20250506_P286",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P580",
+    "rel_path": "Batch10/20250507_P580",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P47",
+    "rel_path": "Batch10/20250502_P47",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P211",
+    "rel_path": "Batch10/20250505_P211",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1031",
+    "rel_path": "Batch10/20250509_P1031",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P44",
+    "rel_path": "Batch10/20250502_P44",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P288",
+    "rel_path": "Batch10/20250506_P288",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P928",
+    "rel_path": "Batch10/20250509_P928",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P83",
+    "rel_path": "Batch10/20250503_P83",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P362",
+    "rel_path": "Batch10/20250506_P362",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P82",
+    "rel_path": "Batch10/20250503_P82",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P511",
+    "rel_path": "Batch10/20250506_P511",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P525",
+    "rel_path": "Batch10/20250507_P525",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1302",
+    "rel_path": "Batch10/20250512_P1302",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P283",
+    "rel_path": "Batch10/20250506_P283",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P733",
+    "rel_path": "Batch10/20250508_P733",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P462",
+    "rel_path": "Batch10/20250506_P462",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1215",
+    "rel_path": "Batch10/20250511_P1215",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P197",
+    "rel_path": "Batch10/20250504_P197",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P13",
+    "rel_path": "Batch10/20250501_P13",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P407",
+    "rel_path": "Batch10/20250506_P407",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P400",
+    "rel_path": "Batch10/20250506_P400",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P836",
+    "rel_path": "Batch10/20250508_P836",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P369",
+    "rel_path": "Batch10/20250506_P369",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P570",
+    "rel_path": "Batch10/20250507_P570",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P269",
+    "rel_path": "Batch10/20250505_P269",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P248",
+    "rel_path": "Batch10/20250505_P248",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P37",
+    "rel_path": "Batch10/20250501_P37",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1492",
+    "rel_path": "Batch10/20250512_P1492",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P679",
+    "rel_path": "Batch10/20250507_P679",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P491",
+    "rel_path": "Batch10/20250506_P491",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P289",
+    "rel_path": "Batch10/20250506_P289",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1001",
+    "rel_path": "Batch10/20250509_P1001",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P522",
+    "rel_path": "Batch10/20250507_P522",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1034",
+    "rel_path": "Batch10/20250509_P1034",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P280",
+    "rel_path": "Batch10/20250505_P280",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P30",
+    "rel_path": "Batch10/20250501_P30",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1411",
+    "rel_path": "Batch10/20250512_P1411",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P78",
+    "rel_path": "Batch10/20250503_P78",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1404",
+    "rel_path": "Batch10/20250512_P1404",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P11",
+    "rel_path": "Batch10/20250501_P11",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1363",
+    "rel_path": "Batch10/20250512_P1363",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P55",
+    "rel_path": "Batch10/20250502_P55",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P409",
+    "rel_path": "Batch10/20250506_P409",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250502_P53",
+    "rel_path": "Batch10/20250502_P53",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1197",
+    "rel_path": "Batch10/20250510_P1197",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1454",
+    "rel_path": "Batch10/20250512_P1454",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1406",
+    "rel_path": "Batch10/20250512_P1406",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P148",
+    "rel_path": "Batch10/20250504_P148",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P660",
+    "rel_path": "Batch10/20250507_P660",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P856",
+    "rel_path": "Batch10/20250509_P856",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P26",
+    "rel_path": "Batch10/20250501_P26",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P387",
+    "rel_path": "Batch10/20250506_P387",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P686",
+    "rel_path": "Batch10/20250508_P686",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1003",
+    "rel_path": "Batch10/20250509_P1003",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1496",
+    "rel_path": "Batch10/20250512_P1496",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P744",
+    "rel_path": "Batch10/20250508_P744",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1512",
+    "rel_path": "Batch10/20250512_P1512",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P117",
+    "rel_path": "Batch10/20250504_P117",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250505_P228",
+    "rel_path": "Batch10/20250505_P228",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1509",
+    "rel_path": "Batch10/20250512_P1509",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1327",
+    "rel_path": "Batch10/20250512_P1327",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1223",
+    "rel_path": "Batch10/20250511_P1223",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P575",
+    "rel_path": "Batch10/20250507_P575",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P1032",
+    "rel_path": "Batch10/20250509_P1032",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1217",
+    "rel_path": "Batch10/20250511_P1217",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P406",
+    "rel_path": "Batch10/20250506_P406",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P992",
+    "rel_path": "Batch10/20250509_P992",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P07",
+    "rel_path": "Batch10/20250501_P07",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P888",
+    "rel_path": "Batch10/20250509_P888",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250509_P894",
+    "rel_path": "Batch10/20250509_P894",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P513",
+    "rel_path": "Batch10/20250507_P513",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P811",
+    "rel_path": "Batch10/20250508_P811",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P763",
+    "rel_path": "Batch10/20250508_P763",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P548",
+    "rel_path": "Batch10/20250507_P548",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P652",
+    "rel_path": "Batch10/20250507_P652",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1403",
+    "rel_path": "Batch10/20250512_P1403",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P461",
+    "rel_path": "Batch10/20250506_P461",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250511_P1224",
+    "rel_path": "Batch10/20250511_P1224",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1465",
+    "rel_path": "Batch10/20250512_P1465",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P193",
+    "rel_path": "Batch10/20250504_P193",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P626",
+    "rel_path": "Batch10/20250507_P626",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P327",
+    "rel_path": "Batch10/20250506_P327",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P837",
+    "rel_path": "Batch10/20250508_P837",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P563",
+    "rel_path": "Batch10/20250507_P563",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1344",
+    "rel_path": "Batch10/20250512_P1344",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250501_P41",
+    "rel_path": "Batch10/20250501_P41",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250508_P698",
+    "rel_path": "Batch10/20250508_P698",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250504_P163",
+    "rel_path": "Batch10/20250504_P163",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250506_P484",
+    "rel_path": "Batch10/20250506_P484",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250512_P1396",
+    "rel_path": "Batch10/20250512_P1396",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250510_P1173",
+    "rel_path": "Batch10/20250510_P1173",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250507_P583",
+    "rel_path": "Batch10/20250507_P583",
+    "score": 1.0
+  },
+  {
+    "type": "single",
+    "id": "Batch10_20250503_P108",
+    "rel_path": "Batch10/20250503_P108",
+    "score": 1.0
+  }
+]

config.yaml ADDED Viewed

	@@ -0,0 +1,48 @@

+# 超声提示多标签分类模型配置文件
+# TransMIL + Query2Label Hybrid Model
+data:
+  # 【需要修改】数据根目录（包含 Report_XXX 文件夹的目录）
+  data_root: "/path/to/your/ReportData_ROI/"
+  # 【需要修改】多标签注释 CSV 文件路径
+  annotation_csv: "/path/to/your/ReportData_ROI/thyroid_multilabel_annotations.csv"
+  # 【需要修改】验证集 JSON 文件路径
+  val_json: "/path/to/your/ReportData_ROI/classification_val_set_single.json"
+  # 【需要修改】测试集 JSON 文件路径
+  test_json: "/path/to/your/ReportData_ROI/classification_test_set_single.json"
+  img_size: 224
+  max_images_per_case: 20
+  num_workers: 8
+model:
+  num_class: 17  # 17类标签（已删除"切除术后"）
+  hidden_dim: 512
+  nheads: 8
+  num_decoder_layers: 2
+  pretrained_resnet: True
+  use_ppeg: False
+training:
+  batch_size: 4
+  epochs: 50
+  lr: 0.0001
+  weight_decay: 0.0001
+  optimizer: "AdamW"
+  # Asymmetric Loss 参数（处理多标签不平衡）
+  gamma_neg: 4
+  gamma_pos: 1
+  clip: 0.05
+  # 内存优化策略
+  use_amp: true  # 混合精度训练
+  gradient_accumulation_steps: 4  # 有效 batch_size = 4 * 4 = 16
+  gradient_checkpointing: true
+  # 学习率调度器
+  scheduler: "cosine"
+  warmup_epochs: 5
+  # 模型保存
+  save_dir: "checkpoints/"
+  save_freq: 5

evaluate.py ADDED Viewed

	@@ -0,0 +1,236 @@

+import os
+import yaml
+import torch
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from sklearn.metrics import (
+    average_precision_score,
+    roc_auc_score,
+    f1_score,
+    precision_score,
+    recall_score,
+    accuracy_score
+)
+# 引入你的模型和数据加载器
+from models.transmil_q2l import TransMIL_Query2Label_E2E
+from thyroid_dataset import create_dataloaders, TARGET_CLASSES
+'''
+# 18类标签定义 (与训练时保持一致)
+TARGET_CLASSES = [
+    "TI-RADS 1级", "TI-RADS 2级", "TI-RADS 3级", "TI-RADS 4a级",
+    "TI-RADS 4b级", "TI-RADS 4c级", "TI-RADS 5级",
+    "钙化", "甲亢", "囊肿", "淋巴结", "胶质潴留", "切除术后",
+    "弥漫性病变", "结节性甲状腺肿", "桥本氏甲状腺炎", "反应性", "转移性"
+]
+'''
+def get_best_checkpoint_path(save_dir):
+    """自动寻找 best checkpoint"""
+    best_path = os.path.join(save_dir, 'checkpoint_best.pth')
+    if os.path.exists(best_path):
+        return best_path
+    # 如果没找到 best，找 latest
+    latest_path = os.path.join(save_dir, 'checkpoint_latest.pth')
+    if os.path.exists(latest_path):
+        print(f"Warning: 'checkpoint_best.pth' not found. Using '{latest_path}' instead.")
+        return latest_path
+    raise FileNotFoundError(f"No checkpoints found in {save_dir}")
+def compute_metrics(y_true, y_pred_probs, threshold=0.5):
+    """
+    计算全面的多标签指标
+    y_true: [N, num_classes] (0 or 1)
+    y_pred_probs: [N, num_classes] (0.0 ~ 1.0)
+    """
+    metrics = {}
+    # 1. 二值化预测
+    y_pred_binary = (y_pred_probs >= threshold).astype(int)
+    # 2. 全局指标 (Global Metrics)
+    # mAP (mean Average Precision) - 最重要的多标签指标
+    metrics['mAP'] = average_precision_score(y_true, y_pred_probs, average='macro')
+    metrics['weighted_mAP'] = average_precision_score(y_true, y_pred_probs, average='weighted')
+    # AUROC (Macro & Micro)
+    try:
+        metrics['macro_auroc'] = roc_auc_score(y_true, y_pred_probs, average='macro')
+        metrics['micro_auroc'] = roc_auc_score(y_true, y_pred_probs, average='micro')
+    except ValueError:
+        metrics['macro_auroc'] = 0.0
+        metrics['micro_auroc'] = 0.0
+    # F1 Score
+    metrics['micro_f1'] = f1_score(y_true, y_pred_binary, average='micro')
+    metrics['macro_f1'] = f1_score(y_true, y_pred_binary, average='macro')
+    # Exact Match Ratio (Subset Accuracy) - 全对才算对
+    metrics['subset_accuracy'] = accuracy_score(y_true, y_pred_binary)
+    # 3. 每类详细指标 (Per-class Metrics)
+    class_metrics = []
+    for i, class_name in enumerate(TARGET_CLASSES):
+        # 提取当前类的真实标签和预测概率
+        yt = y_true[:, i]
+        yp = y_pred_probs[:, i]
+        yb = y_pred_binary[:, i]
+        # 样本数
+        support = int(yt.sum())
+        # 如果该类没有正样本，部分指标无法计算
+        if support > 0:
+            ap = average_precision_score(yt, yp)
+            try:
+                auroc = roc_auc_score(yt, yp)
+            except ValueError:
+                auroc = 0.5 # 只有一个类别存在时无法计算AUC
+            f1 = f1_score(yt, yb)
+            rec = recall_score(yt, yb)
+            prec = precision_score(yt, yb, zero_division=0)
+        else:
+            ap, auroc, f1, rec, prec = 0.0, 0.5, 0.0, 0.0, 0.0
+        class_metrics.append({
+            "Class": class_name,
+            "Support": support,
+            "AP": ap,
+            "AUROC": auroc,
+            "F1": f1,
+            "Precision": prec,
+            "Recall": rec
+        })
+    return metrics, pd.DataFrame(class_metrics)
+def main():
+    # 1. 加载配置
+    config_path = 'config.yaml' # 确保这里路径正确
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Evaluating on {device}")
+    # 2. 准备数据加载器
+    print("Loading Test Data...")
+    _, _, test_loader = create_dataloaders(config)
+    # 3. 初始化模型
+    print("Initializing Model...")
+    model = TransMIL_Query2Label_E2E(
+        num_class=config['model']['num_class'],
+        hidden_dim=config['model']['hidden_dim'],
+        nheads=config['model']['nheads'],
+        num_decoder_layers=config['model']['num_decoder_layers'],
+        pretrained_resnet=False, # 推理时不需要下载预训练权重，直接加载我们自己的权重
+        use_checkpointing=False, # 推理时不需要 checkpointing
+        use_ppeg=config['model'].get('use_ppeg', False)
+    )
+    # 4. 加载权重
+    ckpt_path = get_best_checkpoint_path(config['training']['save_dir'])
+    print(f"Loading checkpoint from: {ckpt_path}")
+    checkpoint = torch.load(ckpt_path, map_location=device, weights_only=False)
+    # 处理 state_dict 键名可能不匹配的问题 (如 module. 前缀)
+    state_dict = checkpoint['model_state_dict']
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        name = k.replace("module.", "")
+        new_state_dict[name] = v
+    model.load_state_dict(new_state_dict)
+    model.to(device)
+    model.eval()
+    # 5. 推理循环
+    print("Running Inference...")
+    all_preds = []
+    all_targets = []
+    with torch.no_grad():
+        for batch in tqdm(test_loader):
+            images = batch['images'].to(device)
+            num_instances = batch['num_instances_per_case']
+            labels = batch['labels'].numpy() # CPU numpy
+            # Forward
+            logits = model(images, num_instances)
+            probs = torch.sigmoid(logits).cpu().numpy()
+            all_preds.append(probs)
+            all_targets.append(labels)
+    # 拼接
+    y_pred_probs = np.concatenate(all_preds, axis=0)
+    y_true = np.concatenate(all_targets, axis=0)
+    # 6. 计算指标
+    print("\nComputing Metrics...")
+    global_metrics, class_df = compute_metrics(y_true, y_pred_probs)
+    # 7. 打印结果
+    print("\n" + "="*60)
+    print(" GLOBAL PERFORMANCE SUMMARY ")
+    print("="*60)
+    print(f" mAP (Macro)   : {global_metrics['mAP']:.4f}")
+    print(f" mAP (Weighted): {global_metrics['weighted_mAP']:.4f}")
+    print(f" AUROC (Macro) : {global_metrics['macro_auroc']:.4f}")
+    print(f" AUROC (Micro) : {global_metrics['micro_auroc']:.4f}")
+    print(f" F1 (Micro)    : {global_metrics['micro_f1']:.4f}")
+    print(f" F1 (Macro)    : {global_metrics['macro_f1']:.4f}")
+    print(f" Subset Acc    : {global_metrics['subset_accuracy']:.4f}")
+    print("-" * 60)
+    print("\n" + "="*100)
+    print(" PER-CLASS PERFORMANCE DETAILS (Sorted by Support) ")
+    print("="*100)
+    # 按样本数量排序
+    class_df = class_df.sort_values(by='Support', ascending=False)
+    # --- 开始修改：手动格式化打印 ---
+    # 定义表头
+    # 中文字符宽度处理技巧：给 Class 列预留足够大的空间 (比如30)
+    # {:<N} 左对齐, {:>N} 右对齐
+    headers = ["Class", "Support", "AP", "AUROC", "F1", "Precision", "Recall"]
+    # 打印表头
+    # {0:<24} 表示第一列左对齐占24格
+    head_fmt = "{:<24} {:>8} {:>10} {:>10} {:>10} {:>12} {:>10}"
+    print(head_fmt.format(*headers))
+    print("-" * 100)
+    # 打印每一行
+    row_fmt = "{:<24} {:>8d} {:>10.4f} {:>10.4f} {:>10.4f} {:>12.4f} {:>10.4f}"
+    for _, row in class_df.iterrows():
+        cls_name = row['Class']
+        display_width = len(cls_name.encode('gbk'))
+        # 计算需要填充的空格数
+        # 目标宽度 24 - 实际显示宽度
+        target_width = 24
+        padding = target_width - display_width
+        # 构造对齐后的字符串
+        aligned_name = cls_name + " " * padding
+        print(f"{aligned_name} {int(row['Support']):>8d} {row['AP']:>10.4f} {row['AUROC']:>10.4f} {row['F1']:>10.4f} {row['Precision']:>12.4f} {row['Recall']:>10.4f}")
+    print("="*100)
+    # 保存结果到 CSV
+    result_csv = os.path.join(config['training']['save_dir'], 'evaluation_report.csv')
+    class_df.to_csv(result_csv, index=False, encoding='utf-8-sig')
+    print(f"\nDetailed report saved to: {result_csv}")
+if __name__ == "__main__":
+    main()

infer_single_case.py ADDED Viewed

	@@ -0,0 +1,244 @@

+"""
+单步推理脚本 - 超声提示多标签分类模型
+Single Case Inference for TransMIL + Query2Label Hybrid Model
+用法:
+    # 指定多个图像文件
+    python infer_single_case.py --images /path/to/img1.png /path/to/img2.png --threshold 0.5
+    # 指定图像文件夹
+    python infer_single_case.py --image_dir /path/to/case_folder/ --threshold 0.5
+"""
+import os
+import sys
+import argparse
+import torch
+import numpy as np
+from PIL import Image
+from torchvision import transforms
+# 添加当前目录到路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from models.transmil_q2l import TransMIL_Query2Label_E2E
+# 17类标签定义
+TARGET_CLASSES = [
+    "TI-RADS 1级", "TI-RADS 2级", "TI-RADS 3级", "TI-RADS 4a级",
+    "TI-RADS 4b级", "TI-RADS 4c级", "TI-RADS 5级",
+    "钙化", "甲亢", "囊肿", "淋巴结", "胶质潴留",
+    "弥漫性病变", "结节性甲状腺肿", "桥本氏甲状腺炎", "反应性", "转移性"
+]
+def load_model(checkpoint_path: str, device: torch.device):
+    """加载预训练模型"""
+    print(f"Loading model from: {checkpoint_path}")
+    # 初始化模型
+    model = TransMIL_Query2Label_E2E(
+        num_class=17,
+        hidden_dim=512,
+        nheads=8,
+        num_decoder_layers=2,
+        pretrained_resnet=False,  # 推理时不需要下载预训练权重
+        use_checkpointing=False,  # 推理时不需要 checkpointing
+        use_ppeg=False
+    )
+    # 加载权重
+    checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
+    state_dict = checkpoint['model_state_dict']
+    # 处理 state_dict 键名可能不匹配的问题 (如 module. 前缀)
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        name = k.replace("module.", "")
+        new_state_dict[name] = v
+    model.load_state_dict(new_state_dict)
+    model.to(device)
+    model.eval()
+    print("Model loaded successfully!")
+    return model
+def preprocess_images(image_paths: list, img_size: int = 224):
+    """预处理图像"""
+    transform = transforms.Compose([
+        transforms.Resize((img_size, img_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                           std=[0.229, 0.224, 0.225])
+    ])
+    images = []
+    valid_paths = []
+    for path in image_paths:
+        if not os.path.exists(path):
+            print(f"Warning: Image not found: {path}")
+            continue
+        try:
+            img = Image.open(path).convert('RGB')
+            img_tensor = transform(img)
+            images.append(img_tensor)
+            valid_paths.append(path)
+        except Exception as e:
+            print(f"Warning: Failed to load image {path}: {e}")
+            continue
+    if len(images) == 0:
+        raise ValueError("No valid images found!")
+    # Stack to batch: [N, C, H, W] - 模型期望直接的图像堆叠，不需要额外的batch维度
+    images_batch = torch.stack(images, dim=0)
+    return images_batch, valid_paths
+def predict(model, images_batch: torch.Tensor, num_images: int,
+            device: torch.device, threshold: float = 0.5):
+    """执行推理"""
+    images_batch = images_batch.to(device)
+    with torch.no_grad():
+        # Forward pass
+        logits = model(images_batch, [num_images])
+        probs = torch.sigmoid(logits).cpu().numpy()[0]  # [num_class]
+    # 根据阈值获取预测标签
+    predictions = (probs >= threshold).astype(int)
+    return probs, predictions
+def format_results(probs: np.ndarray, predictions: np.ndarray, threshold: float):
+    """格式化输出结果"""
+    print("\n" + "=" * 60)
+    print(" 超声提示多标签分类结果")
+    print("=" * 60)
+    print(f" 阈值 (Threshold): {threshold}")
+    print("-" * 60)
+    # 按概率排序
+    sorted_indices = np.argsort(probs)[::-1]
+    print(f"\n{'类别':<20} {'概率':>10} {'预测':>8}")
+    print("-" * 40)
+    predicted_labels = []
+    for idx in sorted_indices:
+        class_name = TARGET_CLASSES[idx]
+        prob = probs[idx]
+        pred = "✓" if predictions[idx] == 1 else ""
+        # 使用 GBK 编码计算显示宽度
+        try:
+            display_width = len(class_name.encode('gbk'))
+        except:
+            display_width = len(class_name) * 2
+        padding = 20 - display_width
+        aligned_name = class_name + " " * max(0, padding)
+        print(f"{aligned_name} {prob:>10.4f} {pred:>8}")
+        if predictions[idx] == 1:
+            predicted_labels.append(class_name)
+    print("\n" + "=" * 60)
+    print(" 预测标签汇总")
+    print("=" * 60)
+    if predicted_labels:
+        for label in predicted_labels:
+            print(f"  • {label}")
+    else:
+        print("  无预测标签（所有类别概率均低于阈值）")
+    print("=" * 60 + "\n")
+    return predicted_labels
+def main():
+    parser = argparse.ArgumentParser(description='超声提示多标签分类 - 单步推理')
+    parser.add_argument('--images', nargs='*', default=None,
+                        help='图像路径列表 (支持多个图像)')
+    parser.add_argument('--image_dir', type=str, default=None,
+                        help='图像文件夹路径 (自动加载文件夹内所有图像)')
+    parser.add_argument('--checkpoint', type=str,
+                        default='checkpoints/checkpoint_best.pth',
+                        help='模型权重路径')
+    parser.add_argument('--threshold', type=float, default=0.5,
+                        help='分类阈值 (default: 0.5)')
+    parser.add_argument('--device', type=str, default='auto',
+                        help='设备: auto, cuda, cpu')
+    args = parser.parse_args()
+    # 收集图像路径
+    image_paths = []
+    # 从 --images 参数收集
+    if args.images:
+        image_paths.extend(args.images)
+    # 从 --image_dir 参数收集
+    if args.image_dir:
+        if not os.path.isdir(args.image_dir):
+            print(f"Error: Image directory not found: {args.image_dir}")
+            sys.exit(1)
+        # 支持的图像格式
+        image_extensions = {'.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif'}
+        for filename in sorted(os.listdir(args.image_dir)):
+            ext = os.path.splitext(filename)[1].lower()
+            if ext in image_extensions:
+                image_paths.append(os.path.join(args.image_dir, filename))
+        print(f"Found {len(image_paths)} images in {args.image_dir}")
+    # 检查是否有图像输入
+    if not image_paths:
+        print("Error: No images specified. Use --images or --image_dir")
+        parser.print_help()
+        sys.exit(1)
+    # 设置设备
+    if args.device == 'auto':
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    else:
+        device = torch.device(args.device)
+    print(f"Using device: {device}")
+    # 处理相对路径
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    checkpoint_path = args.checkpoint
+    if not os.path.isabs(checkpoint_path):
+        checkpoint_path = os.path.join(script_dir, checkpoint_path)
+    # 加载模型
+    model = load_model(checkpoint_path, device)
+    # 预处理图像
+    print(f"\nProcessing {len(image_paths)} image(s)...")
+    images_batch, valid_paths = preprocess_images(image_paths)
+    print(f"Successfully loaded {len(valid_paths)} image(s)")
+    # 推理
+    probs, predictions = predict(model, images_batch, len(valid_paths),
+                                  device, args.threshold)
+    # 输出结果
+    predicted_labels = format_results(probs, predictions, args.threshold)
+    # 返回预测标签列表（供程序调用）
+    return predicted_labels
+if __name__ == "__main__":
+    main()

models/__init__.py ADDED Viewed

	@@ -0,0 +1,13 @@

+# Thyroid Ultrasound Hint Multi-Label Classification
+from models.transmil_q2l import TransMIL_Query2Label_E2E
+from models.aslloss import AsymmetricLoss, AsymmetricLossOptimized
+from models.transformer import TransformerDecoder, TransformerDecoderLayer
+__all__ = [
+    'TransMIL_Query2Label_E2E',
+    'AsymmetricLoss',
+    'AsymmetricLossOptimized',
+    'TransformerDecoder',
+    'TransformerDecoderLayer',
+]

models/aslloss.py ADDED Viewed

	@@ -0,0 +1,115 @@

+"""
+    Most borrow from: https://github.com/Alibaba-MIIL/ASL
+"""
+import torch
+import torch.nn as nn
+class AsymmetricLoss(nn.Module):
+    def __init__(self, gamma_neg=4, gamma_pos=1, clip=0.05, eps=1e-8, disable_torch_grad_focal_loss=False):
+        super(AsymmetricLoss, self).__init__()
+        self.gamma_neg = gamma_neg
+        self.gamma_pos = gamma_pos
+        self.clip = clip
+        self.disable_torch_grad_focal_loss = disable_torch_grad_focal_loss
+        self.eps = eps
+    def forward(self, x, y):
+        """"
+        Parameters
+        ----------
+        x: input logits
+        y: targets (multi-label binarized vector)
+        """
+        # Calculating Probabilities
+        x_sigmoid = torch.sigmoid(x)
+        xs_pos = x_sigmoid
+        xs_neg = 1 - x_sigmoid
+        # Asymmetric Clipping
+        if self.clip is not None and self.clip > 0:
+            xs_neg = (xs_neg + self.clip).clamp(max=1)
+        # Basic CE calculation
+        los_pos = y * torch.log(xs_pos.clamp(min=self.eps, max=1-self.eps))
+        los_neg = (1 - y) * torch.log(xs_neg.clamp(min=self.eps, max=1-self.eps))
+        loss = los_pos + los_neg
+        # Asymmetric Focusing
+        if self.gamma_neg > 0 or self.gamma_pos > 0:
+            if self.disable_torch_grad_focal_loss:
+                torch._C.set_grad_enabled(False)
+            pt0 = xs_pos * y
+            pt1 = xs_neg * (1 - y)  # pt = p if t > 0 else 1-p
+            pt = pt0 + pt1
+            one_sided_gamma = self.gamma_pos * y + self.gamma_neg * (1 - y)
+            one_sided_w = torch.pow(1 - pt, one_sided_gamma)
+            if self.disable_torch_grad_focal_loss:
+                torch._C.set_grad_enabled(True)
+            loss *= one_sided_w
+        return -loss.sum()
+class AsymmetricLossOptimized(nn.Module):
+    ''' Notice - optimized version, minimizes memory allocation and gpu uploading,
+    favors inplace operations'''
+    def __init__(self, gamma_neg=4, gamma_pos=1, clip=0.05, eps=1e-5, disable_torch_grad_focal_loss=False):
+        super(AsymmetricLossOptimized, self).__init__()
+        self.gamma_neg = gamma_neg
+        self.gamma_pos = gamma_pos
+        self.clip = clip
+        self.disable_torch_grad_focal_loss = disable_torch_grad_focal_loss
+        self.eps = eps
+        self.targets = self.anti_targets = self.xs_pos = self.xs_neg = self.asymmetric_w = self.loss = None
+    def forward(self, x, y):
+        """"
+        Parameters
+        ----------
+        x: input logits
+        y: targets (multi-label binarized vector)
+        """
+        self.targets = y
+        self.anti_targets = 1 - y
+        # Calculating Probabilities
+        self.xs_pos = torch.sigmoid(x)
+        self.xs_neg = 1.0 - self.xs_pos
+        # Asymmetric Clipping
+        if self.clip is not None and self.clip > 0:
+            self.xs_neg.add_(self.clip).clamp_(max=1)
+        # Basic CE calculation
+        self.loss = self.targets * torch.log(self.xs_pos.clamp(min=self.eps))
+        self.loss.add_(self.anti_targets * torch.log(self.xs_neg.clamp(min=self.eps)))
+        # Asymmetric Focusing
+        if self.gamma_neg > 0 or self.gamma_pos > 0:
+            if self.disable_torch_grad_focal_loss:
+                with torch.no_grad():
+                    # if self.disable_torch_grad_focal_loss:
+                    #     torch._C.set_grad_enabled(False)
+                    self.xs_pos = self.xs_pos * self.targets
+                    self.xs_neg = self.xs_neg * self.anti_targets
+                    self.asymmetric_w = torch.pow(1 - self.xs_pos - self.xs_neg,
+                                                self.gamma_pos * self.targets + self.gamma_neg * self.anti_targets)
+                    # if self.disable_torch_grad_focal_loss:
+                    #     torch._C.set_grad_enabled(True)
+                self.loss *= self.asymmetric_w
+            else:
+                self.xs_pos = self.xs_pos * self.targets
+                self.xs_neg = self.xs_neg * self.anti_targets
+                self.asymmetric_w = torch.pow(1 - self.xs_pos - self.xs_neg,
+                                            self.gamma_pos * self.targets + self.gamma_neg * self.anti_targets)
+                self.loss *= self.asymmetric_w
+        _loss = - self.loss.sum() / x.size(0)
+        _loss = _loss / y.size(1) * 1000
+        return _loss

models/transformer.py ADDED Viewed

	@@ -0,0 +1,374 @@

+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Q2L Transformer class.
+Most borrow from DETR except:
+    * remove self-attention by default.
+Copy-paste from torch.nn.Transformer with modifications:
+    * positional encodings are passed in MHattention
+    * extra LN at the end of encoder is removed
+    * decoder returns a stack of activations from all decoding layers
+    * using modified multihead attention from nn_multiheadattention.py
+"""
+import copy
+from typing import Optional, List
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+from torch.nn import MultiheadAttention
+class Transformer(nn.Module):
+    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
+                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False,
+                 return_intermediate_dec=False,
+                 rm_self_attn_dec=True, rm_first_self_attn=True,
+                 ):
+        super().__init__()
+        self.num_encoder_layers = num_encoder_layers
+        if num_decoder_layers > 0:
+            encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
+                                                    dropout, activation, normalize_before)
+            encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+            self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+        decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
+                                                dropout, activation, normalize_before)
+        decoder_norm = nn.LayerNorm(d_model)
+        self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
+                                          return_intermediate=return_intermediate_dec)
+        self._reset_parameters()
+        self.d_model = d_model
+        self.nhead = nhead
+        self.rm_self_attn_dec = rm_self_attn_dec
+        self.rm_first_self_attn = rm_first_self_attn
+        if self.rm_self_attn_dec or self.rm_first_self_attn:
+            self.rm_self_attn_dec_func()
+        # self.debug_mode = False
+        # self.set_debug_mode(self.debug_mode)
+    def rm_self_attn_dec_func(self):
+        total_modifie_layer_num = 0
+        rm_list = []
+        for idx, layer in enumerate(self.decoder.layers):
+            if idx == 0 and not self.rm_first_self_attn:
+                continue
+            if idx != 0 and not self.rm_self_attn_dec:
+                continue
+            layer.omit_selfattn = True
+            del layer.self_attn
+            del layer.dropout1
+            del layer.norm1
+            total_modifie_layer_num += 1
+            rm_list.append(idx)
+        # remove some self-attention layer
+        # print("rm {} layer: {}".format(total_modifie_layer_num, rm_list))
+    def set_debug_mode(self, status):
+        print("set debug mode to {}!!!".format(status))
+        self.debug_mode = status
+        if hasattr(self, 'encoder'):
+            for idx, layer in enumerate(self.encoder.layers):
+                layer.debug_mode = status
+                layer.debug_name = str(idx)
+        if hasattr(self, 'decoder'):
+            for idx, layer in enumerate(self.decoder.layers):
+                layer.debug_mode = status
+                layer.debug_name = str(idx)
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+    def forward(self, src, query_embed, pos_embed, mask=None):
+        # flatten NxCxHxW to HWxNxC
+        bs, c, h, w = src.shape
+        src = src.flatten(2).permute(2, 0, 1)
+        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
+        query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+        if mask is not None:
+            mask = mask.flatten(1)
+        if self.num_encoder_layers > 0:
+            memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
+        else:
+            memory = src
+        tgt = torch.zeros_like(query_embed)
+        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
+                          pos=pos_embed, query_pos=query_embed)
+        return hs.transpose(1, 2), memory[:h*w].permute(1, 2, 0).view(bs, c, h, w)
+class TransformerEncoder(nn.Module):
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super().__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+    def forward(self, src,
+                mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        output = src
+        for layer in self.layers:
+            output = layer(output, src_mask=mask,
+                           src_key_padding_mask=src_key_padding_mask, pos=pos)
+        if self.norm is not None:
+            output = self.norm(output)
+        return output
+class TransformerDecoder(nn.Module):
+    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
+        super().__init__()
+        self.layers = _get_clones(decoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+        self.return_intermediate = return_intermediate
+    def forward(self, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        output = tgt
+        intermediate = []
+        for layer in self.layers:
+            output = layer(output, memory, tgt_mask=tgt_mask,
+                           memory_mask=memory_mask,
+                           tgt_key_padding_mask=tgt_key_padding_mask,
+                           memory_key_padding_mask=memory_key_padding_mask,
+                           pos=pos, query_pos=query_pos)
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+        if self.norm is not None:
+            output = self.norm(output)
+            if self.return_intermediate:
+                intermediate.pop()
+                intermediate.append(output)
+        if self.return_intermediate:
+            return torch.stack(intermediate)
+        return output.unsqueeze(0)
+class TransformerEncoderLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+        self.debug_mode = False
+        self.debug_name = None
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+    def forward_post(self,
+                     src,
+                     src_mask: Optional[Tensor] = None,
+                     src_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(src, pos)
+        src2, corr = self.self_attn(q, k, value=src, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+    def forward_pre(self, src,
+                    src_mask: Optional[Tensor] = None,
+                    src_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None):
+        src2 = self.norm1(src)
+        q = k = self.with_pos_embed(src2, pos)
+        src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src2 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
+        src = src + self.dropout2(src2)
+        return src
+    def forward(self, src,
+                src_mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
+        return self.forward_post(src, src_mask, src_key_padding_mask, pos)
+class TransformerDecoderLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+        self.debug_mode = False
+        self.debug_name = None
+        self.omit_selfattn = False
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+    def forward_post(self, tgt, memory,
+                     tgt_mask: Optional[Tensor] = None,
+                     memory_mask: Optional[Tensor] = None,
+                     tgt_key_padding_mask: Optional[Tensor] = None,
+                     memory_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(tgt, query_pos)
+        if not self.omit_selfattn:
+            tgt2, sim_mat_1 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
+                                key_padding_mask=tgt_key_padding_mask)
+            tgt = tgt + self.dropout1(tgt2)
+            tgt = self.norm1(tgt)
+        tgt2, sim_mat_2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
+                                key=self.with_pos_embed(memory, pos),
+                                value=memory, attn_mask=memory_mask,
+                                key_padding_mask=memory_key_padding_mask)
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        return tgt
+    def forward_pre(self, tgt, memory,
+                    tgt_mask: Optional[Tensor] = None,
+                    memory_mask: Optional[Tensor] = None,
+                    tgt_key_padding_mask: Optional[Tensor] = None,
+                    memory_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None):
+        tgt2 = self.norm1(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+    def forward(self, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(tgt, memory, tgt_mask, memory_mask,
+                                    tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
+        return self.forward_post(tgt, memory, tgt_mask, memory_mask,
+                                 tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
+def _get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+def build_transformer(args):
+    return Transformer(
+        d_model=args.hidden_dim,
+        dropout=args.dropout,
+        nhead=args.nheads,
+        dim_feedforward=args.dim_feedforward,
+        num_encoder_layers=args.enc_layers,
+        num_decoder_layers=args.dec_layers,
+        normalize_before=args.pre_norm,
+        return_intermediate_dec=False,
+        rm_self_attn_dec=not args.keep_other_self_attn_dec,
+        rm_first_self_attn=not args.keep_first_self_attn_dec,
+    )
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(F"activation should be relu/gelu, not {activation}.")

models/transmil_q2l.py ADDED Viewed

	@@ -0,0 +1,589 @@

+"""
+Hybrid TransMIL + Query2Label Architecture
+Combines:
+- TransMIL's instance-level feature aggregation (with Nystrom attention)
+- Query2Label's learnable label queries with cross-attention decoder
+- End-to-end training with ResNet-50 backbone
+Key Innovation: Extract sequence features from TransMIL BEFORE CLS aggregation,
+allowing Q2L label queries to cross-attend across all ultrasound images per case.
+"""
+import os
+import sys
+# Add models directory to path for local imports
+_models_dir = os.path.dirname(os.path.abspath(__file__))
+if _models_dir not in sys.path:
+    sys.path.insert(0, _models_dir)
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision
+import numpy as np
+from torch.utils.checkpoint import checkpoint_sequential
+# Import TransMIL components (from nystrom-attention package)
+from nystrom_attention import NystromAttention
+# Import Q2L Transformer components from local transformer.py
+try:
+    from models.transformer import TransformerDecoder, TransformerDecoderLayer
+except ImportError:
+    try:
+        from transformer import TransformerDecoder, TransformerDecoderLayer
+    except ImportError:
+        print("Warning: Could not import Q2L Transformer components.")
+# ============================================================================
+# TransMIL Components (Modified)
+# ============================================================================
+class TransLayer(nn.Module):
+    """Transformer layer with Nystrom attention (from TransMIL)"""
+    def __init__(self, norm_layer=nn.LayerNorm, dim=512):
+        super().__init__()
+        self.norm = norm_layer(dim)
+        self.attn = NystromAttention(
+            dim=dim,
+            dim_head=dim // 8,
+            heads=8,
+            num_landmarks=dim // 2,
+            pinv_iterations=6,
+            residual=True,
+            dropout=0.1
+        )
+    def forward(self, x):
+        x = x + self.attn(self.norm(x))
+        return x
+class TransMILFeatureExtractor(nn.Module):
+    """
+    Modified TransMIL that outputs sequence features instead of aggregated CLS token.
+    Based on TransMIL.py but extracts features BEFORE CLS aggregation (line 83 output).
+    Uses learned 1D position encoding instead of PPEG for simplicity.
+    Args:
+        input_dim: Dimension of input features (2048 for ResNet-50)
+        hidden_dim: Dimension of hidden features (512 default)
+        use_ppeg: Whether to use PPEG (2D positional encoding) or learned 1D encoding
+        max_seq_len: Maximum sequence length for position encoding
+    """
+    def __init__(self, input_dim=2048, hidden_dim=512, use_ppeg=False, max_seq_len=1024):
+        super().__init__()
+        # Feature projection (TransMIL line 50)
+        self.fc1 = nn.Sequential(nn.Linear(input_dim, hidden_dim), nn.ReLU())
+        # Learnable CLS token (TransMIL line 51)
+        self.cls_token = nn.Parameter(torch.randn(1, 1, hidden_dim))
+        # Transformer layers (TransMIL lines 53-54)
+        self.layer1 = TransLayer(dim=hidden_dim)
+        self.layer2 = TransLayer(dim=hidden_dim)
+        # LayerNorm (TransMIL line 55)
+        self.norm = nn.LayerNorm(hidden_dim)
+        # Position encoding
+        self.use_ppeg = use_ppeg
+        if not use_ppeg:
+            # Learned 1D position encoding (simpler than PPEG)
+            self.pos_embedding = nn.Parameter(torch.randn(1, max_seq_len, hidden_dim))
+        else:
+            # PPEG: Position-aware Patch Embedding Generator (requires 2D reshaping)
+            self.pos_layer = PPEG(dim=hidden_dim)
+    def forward(self, features, mask=None):
+        """
+        Args:
+            features: [B, N, input_dim] - Instance features (e.g., from ResNet-50)
+            mask: [B, N] - Padding mask (True = valid instance, False = padded)
+        Returns:
+            seq_features: [B, 1+N, hidden_dim] - Sequence features (CLS + instances)
+            attn_mask: [B, 1+N] - Attention mask for decoder
+        """
+        B, N, _ = features.shape
+        # Project features (TransMIL line 63)
+        h = self.fc1(features)  # [B, N, hidden_dim]
+        # Handle PPEG padding if needed
+        if self.use_ppeg:
+            # Pad to nearest square for PPEG (TransMIL lines 65-69)
+            H = h.shape[1]
+            _H, _W = int(np.ceil(np.sqrt(H))), int(np.ceil(np.sqrt(H)))
+            add_length = _H * _W - H
+            if add_length > 0:
+                h = torch.cat([h, h[:, :add_length, :]], dim=1)  # [B, N_padded, hidden_dim]
+                # Update mask
+                if mask is not None:
+                    pad_mask = torch.zeros(B, add_length, dtype=torch.bool, device=mask.device)
+                    mask = torch.cat([mask, pad_mask], dim=1)
+        # Add CLS token (TransMIL lines 72-74)
+        cls_tokens = self.cls_token.expand(B, -1, -1)
+        h = torch.cat([cls_tokens, h], dim=1)  # [B, 1+N, hidden_dim]
+        # Update mask to include CLS (always valid)
+        if mask is not None:
+            cls_mask = torch.ones(B, 1, dtype=torch.bool, device=mask.device)
+            attn_mask = torch.cat([cls_mask, mask], dim=1)  # [B, 1+N]
+        else:
+            attn_mask = torch.ones(B, h.shape[1], dtype=torch.bool, device=h.device)
+        # TransLayer 1 (TransMIL line 77)
+        h = self.layer1(h)  # [B, 1+N, hidden_dim]
+        # Position encoding
+        if self.use_ppeg:
+            # PPEG (TransMIL line 80)
+            h = self.pos_layer(h, _H, _W)
+        else:
+            # Learned 1D position encoding
+            seq_len = h.shape[1]
+            h = h + self.pos_embedding[:, :seq_len, :]
+        # TransLayer 2 (TransMIL line 83)
+        h = self.layer2(h)  # [B, 1+N, hidden_dim]
+        # LayerNorm (TransMIL line 86, but keep full sequence)
+        h = self.norm(h)  # [B, 1+N, hidden_dim]
+        # CRITICAL: Return full sequence, not just CLS token
+        return h, attn_mask
+class PPEG(nn.Module):
+    """
+    Position-aware Patch Embedding Generator (from TransMIL)
+    Uses 2D depthwise convolutions to inject spatial positional information.
+    """
+    def __init__(self, dim=512):
+        super().__init__()
+        self.proj = nn.Conv2d(dim, dim, 7, 1, 7 // 2, groups=dim)
+        self.proj1 = nn.Conv2d(dim, dim, 5, 1, 5 // 2, groups=dim)
+        self.proj2 = nn.Conv2d(dim, dim, 3, 1, 3 // 2, groups=dim)
+    def forward(self, x, H, W):
+        """
+        Args:
+            x: [B, 1+N, C] - Token sequence (CLS + instances)
+            H, W: Grid dimensions (H * W >= N)
+        """
+        B, _, C = x.shape
+        # Separate CLS token and feature tokens
+        cls_token, feat_token = x[:, 0], x[:, 1:]
+        # Reshape to 2D grid
+        cnn_feat = feat_token.transpose(1, 2).view(B, C, H, W)
+        # Apply 2D convolutions
+        x = self.proj(cnn_feat) + cnn_feat + self.proj1(cnn_feat) + self.proj2(cnn_feat)
+        # Flatten back to sequence
+        x = x.flatten(2).transpose(1, 2)
+        # Concatenate CLS token back
+        x = torch.cat((cls_token.unsqueeze(1), x), dim=1)
+        return x
+# ============================================================================
+# Query2Label Components (Adapted for Sequences)
+# ============================================================================
+class GroupWiseLinear(nn.Module):
+    """
+    Group-wise linear layer for per-class classification (from Q2L).
+    Applies a separate linear transformation for each class.
+    """
+    def __init__(self, num_class, hidden_dim, bias=True):
+        super().__init__()
+        self.num_class = num_class
+        self.hidden_dim = hidden_dim
+        self.bias = bias
+        self.W = nn.Parameter(torch.Tensor(1, num_class, hidden_dim))
+        if bias:
+            self.b = nn.Parameter(torch.Tensor(1, num_class))
+        self.reset_parameters()
+    def reset_parameters(self):
+        import math
+        stdv = 1. / math.sqrt(self.W.size(2))
+        for i in range(self.num_class):
+            self.W[0][i].data.uniform_(-stdv, stdv)
+        if self.bias:
+            for i in range(self.num_class):
+                self.b[0][i].data.uniform_(-stdv, stdv)
+    def forward(self, x):
+        """
+        Args:
+            x: [B, num_class, hidden_dim]
+        Returns:
+            logits: [B, num_class]
+        """
+        # Element-wise multiplication and sum over hidden_dim
+        x = (self.W * x).sum(-1)  # [B, num_class]
+        if self.bias:
+            x = x + self.b
+        return x
+class HybridQuery2Label(nn.Module):
+    """
+    Query2Label decoder adapted for sequence inputs (not spatial features).
+    Uses learnable label queries to cross-attend to instance sequence from TransMIL.
+    Based on query2label.py but modified to accept [B, 1+N, hidden_dim] sequences
+    instead of [B, C, H, W] spatial features.
+    Args:
+        num_class: Number of label classes
+        hidden_dim: Dimension of features (512)
+        nheads: Number of attention heads
+        num_decoder_layers: Number of transformer decoder layers
+        dim_feedforward: Dimension of feedforward network
+        dropout: Dropout rate
+    """
+    def __init__(
+        self,
+        num_class,
+        hidden_dim=512,
+        nheads=8,
+        num_decoder_layers=2,
+        dim_feedforward=2048,
+        dropout=0.1,
+        normalize_before=False
+    ):
+        super().__init__()
+        self.num_class = num_class
+        self.hidden_dim = hidden_dim
+        # Label query embeddings (Q2L line 68)
+        self.query_embed = nn.Embedding(num_class, hidden_dim)
+        # Transformer decoder (Q2L uses transformer.py)
+        decoder_layer = TransformerDecoderLayer(
+            d_model=hidden_dim,
+            nhead=nheads,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            normalize_before=normalize_before
+        )
+        decoder_norm = nn.LayerNorm(hidden_dim)
+        self.decoder = TransformerDecoder(
+            decoder_layer,
+            num_decoder_layers,
+            decoder_norm,
+            return_intermediate=False
+        )
+        # Group-wise linear classifier (Q2L line 69)
+        self.fc = GroupWiseLinear(num_class, hidden_dim, bias=True)
+    def forward(self, sequence_features, memory_key_padding_mask=None):
+        """
+        Args:
+            sequence_features: [B, 1+N, hidden_dim] - Sequence from TransMIL
+            memory_key_padding_mask: [B, 1+N] - Padding mask (True = ignore, False = valid)
+                                                 NOTE: PyTorch convention is inverted!
+        Returns:
+            logits: [B, num_class] - Multi-label classification logits
+        """
+        B = sequence_features.shape[0]
+        # Transpose for decoder: expects [seq_len, B, hidden_dim]
+        memory = sequence_features.permute(1, 0, 2)  # [1+N, B, hidden_dim]
+        # Label queries (Q2L line 77)
+        query_embed = self.query_embed.weight  # [num_class, hidden_dim]
+        query_embed = query_embed.unsqueeze(1).repeat(1, B, 1)  # [num_class, B, hidden_dim]
+        # Initialize target (zero tensor)
+        tgt = torch.zeros_like(query_embed)  # [num_class, B, hidden_dim]
+        # Cross-attention decoder (Q2L line 78)
+        # Queries attend to instance sequence via cross-attention
+        hs = self.decoder(
+            tgt=tgt,
+            memory=memory,
+            memory_key_padding_mask=memory_key_padding_mask,
+            pos=None,  # No positional encoding (already in TransMIL)
+            query_pos=query_embed
+        )  # [1, num_class, B, hidden_dim] if return_intermediate=False
+        # Handle output shape
+        if hs.dim() == 4:
+            hs = hs[-1]  # Take last layer: [num_class, B, hidden_dim]
+        # Transpose to [B, num_class, hidden_dim]
+        hs = hs.permute(1, 0, 2)  # [B, num_class, hidden_dim]
+        # Group-wise linear classification (Q2L line 79)
+        logits = self.fc(hs)  # [B, num_class]
+        return logits
+# ============================================================================
+# ResNet-50 Backbone
+# ============================================================================
+class ResNet50Backbone(nn.Module):
+    """
+    ResNet-50 feature extractor with Global Average Pooling.
+    Extracts 2048-dimensional features from images for TransMIL input.
+    Supports gradient checkpointing for memory efficiency.
+    Args:
+        pretrained: Use ImageNet pre-trained weights
+        use_checkpointing: Enable gradient checkpointing (saves memory)
+    """
+    def __init__(self, pretrained=True, use_checkpointing=False):
+        super().__init__()
+        # Load ResNet-50
+        resnet = torchvision.models.resnet50(pretrained=pretrained)
+        # Remove final FC layer and avgpool
+        # Output of layer4: [B, 2048, 7, 7] for 224x224 input
+        self.features = nn.Sequential(*list(resnet.children())[:-2])
+        # Global Average Pooling
+        self.gap = nn.AdaptiveAvgPool2d(1)
+        self.use_checkpointing = use_checkpointing
+    def forward(self, images):
+        """
+        Args:
+            images: [B*N, 3, H, W] - Batch of images (flattened across cases)
+        Returns:
+            features: [B*N, 2048] - Instance features
+        """
+        if self.training and self.use_checkpointing:
+            # Gradient checkpointing: segment backbone into chunks
+            # Trades compute for memory (recomputes activations during backward)
+            x = checkpoint_sequential(self.features, segments=4, input=images)
+        else:
+            x = self.features(images)  # [B*N, 2048, 7, 7]
+        x = self.gap(x)  # [B*N, 2048, 1, 1]
+        x = x.flatten(1)  # [B*N, 2048]
+        return x
+# ============================================================================
+# Complete End-to-End Model
+# ============================================================================
+class TransMIL_Query2Label_E2E(nn.Module):
+    """
+    Complete end-to-end model: Images → ResNet-50 → TransMIL → Q2L → Logits
+    Pipeline:
+        1. ResNet-50 extracts features from each ultrasound image
+        2. TransMIL aggregates variable-length instance sequences with attention
+        3. Query2Label decoder performs multi-label classification via cross-attention
+    Args:
+        num_class: Number of label classes (default 30)
+        hidden_dim: Hidden dimension for TransMIL and Q2L (default 512)
+        nheads: Number of attention heads in Q2L decoder
+        num_decoder_layers: Number of Q2L decoder layers
+        pretrained_resnet: Use ImageNet pre-trained ResNet-50
+        use_checkpointing: Enable gradient checkpointing for ResNet-50
+        use_ppeg: Use PPEG position encoding (vs learned 1D)
+    """
+    def __init__(
+        self,
+        num_class=30,
+        hidden_dim=512,
+        nheads=8,
+        num_decoder_layers=2,
+        pretrained_resnet=True,
+        use_checkpointing=False,
+        use_ppeg=False
+    ):
+        super().__init__()
+        # ResNet-50 backbone
+        self.backbone = ResNet50Backbone(
+            pretrained=pretrained_resnet,
+            use_checkpointing=use_checkpointing
+        )
+        # TransMIL feature extractor (no PPEG by default, learned 1D position encoding)
+        self.feature_extractor = TransMILFeatureExtractor(
+            input_dim=2048,
+            hidden_dim=hidden_dim,
+            use_ppeg=use_ppeg
+        )
+        # Query2Label decoder
+        self.q2l_decoder = HybridQuery2Label(
+            num_class=num_class,
+            hidden_dim=hidden_dim,
+            nheads=nheads,
+            num_decoder_layers=num_decoder_layers
+        )
+    def forward(self, images, num_instances_per_case):
+        """
+        Args:
+            images: [B*N_total, 3, H, W] - All images flattened across batch
+            num_instances_per_case: [B] or list - Number of images per case
+        Returns:
+            logits: [B, num_class] - Multi-label classification logits
+        """
+        # Convert to tensor if list
+        if isinstance(num_instances_per_case, list):
+            num_instances_per_case = torch.tensor(num_instances_per_case, device=images.device)
+        B = len(num_instances_per_case)
+        # Step 1: Extract features from all images
+        all_features = self.backbone(images)  # [B*N_total, 2048]
+        # Step 2: Reshape to [B, max_N, 2048] with padding
+        max_N = int(num_instances_per_case.max().item())
+        features_padded = torch.zeros(B, max_N, 2048, device=images.device)
+        masks = torch.zeros(B, max_N, dtype=torch.bool, device=images.device)
+        idx = 0
+        for i, n in enumerate(num_instances_per_case):
+            n = int(n.item()) if torch.is_tensor(n) else int(n)
+            features_padded[i, :n] = all_features[idx:idx+n]
+            masks[i, :n] = True  # True = valid instance
+            idx += n
+        # Step 3: TransMIL sequence features
+        seq_features, attn_mask = self.feature_extractor(features_padded, masks)
+        # seq_features: [B, 1+max_N, 512]
+        # attn_mask: [B, 1+max_N] where True = valid, False = padded
+        # Step 4: Q2L decoder
+        # IMPORTANT: PyTorch MultiheadAttention uses inverted mask convention!
+        # memory_key_padding_mask: True = ignore, False = attend
+        # So we need to invert our mask
+        decoder_mask = ~attn_mask  # Invert: True = padded (ignore)
+        logits = self.q2l_decoder(seq_features, memory_key_padding_mask=decoder_mask)
+        # logits: [B, num_class]
+        return logits
+    def freeze_backbone(self):
+        """Freeze ResNet-50 backbone for training only TransMIL+Q2L"""
+        for param in self.backbone.parameters():
+            param.requires_grad = False
+    def unfreeze_backbone(self):
+        """Unfreeze ResNet-50 for end-to-end fine-tuning"""
+        for param in self.backbone.parameters():
+            param.requires_grad = True
+# ============================================================================
+# Testing
+# ============================================================================
+if __name__ == "__main__":
+    print("Testing TransMIL_Query2Label_E2E model...")
+    # Model config
+    num_class = 30
+    batch_size = 2
+    num_instances = [8, 12]  # Variable N per case
+    img_size = 224
+    # Create model
+    model = TransMIL_Query2Label_E2E(
+        num_class=num_class,
+        hidden_dim=512,
+        nheads=8,
+        num_decoder_layers=2,
+        pretrained_resnet=False,  # Faster for testing
+        use_checkpointing=False,
+        use_ppeg=False
+    )
+    # Create dummy data
+    total_images = sum(num_instances)
+    images = torch.randn(total_images, 3, img_size, img_size)
+    print(f"\nInput shapes:")
+    print(f"  Images: {images.shape}")
+    print(f"  Num instances per case: {num_instances}")
+    # Forward pass
+    model.eval()
+    with torch.no_grad():
+        logits = model(images, num_instances)
+    print(f"\nOutput shape:")
+    print(f"  Logits: {logits.shape}")
+    print(f"  Expected: [{batch_size}, {num_class}]")
+    assert logits.shape == (batch_size, num_class), "Output shape mismatch!"
+    print("\n✓ Model test passed!")
+    # Test individual components
+    print("\n" + "="*60)
+    print("Testing individual components...")
+    print("="*60)
+    # Test TransMILFeatureExtractor
+    print("\n1. TransMILFeatureExtractor")
+    feature_extractor = TransMILFeatureExtractor(input_dim=2048, hidden_dim=512)
+    features = torch.randn(2, 10, 2048)
+    mask = torch.ones(2, 10, dtype=torch.bool)
+    seq_features, attn_mask = feature_extractor(features, mask)
+    print(f"   Input: {features.shape}, Output: {seq_features.shape}")
+    assert seq_features.shape == (2, 11, 512)  # 1 CLS + 10 instances
+    print("   ✓ Passed")
+    # Test HybridQuery2Label
+    print("\n2. HybridQuery2Label")
+    decoder = HybridQuery2Label(num_class=30, hidden_dim=512)
+    seq_features = torch.randn(2, 11, 512)
+    logits = decoder(seq_features)
+    print(f"   Input: {seq_features.shape}, Output: {logits.shape}")
+    assert logits.shape == (2, 30)
+    print("   ✓ Passed")
+    # Test ResNet50Backbone
+    print("\n3. ResNet50Backbone")
+    backbone = ResNet50Backbone(pretrained=False)
+    images = torch.randn(20, 3, 224, 224)
+    features = backbone(images)
+    print(f"   Input: {images.shape}, Output: {features.shape}")
+    assert features.shape == (20, 2048)
+    print("   ✓ Passed")
+    print("\n" + "="*60)
+    print("All tests passed! ✓")
+    print("="*60)

requirements.txt ADDED Viewed

	@@ -0,0 +1,12 @@

+# 超声提示多标签分类模型 - 依赖列表
+# TransMIL + Query2Label Hybrid Model Requirements
+torch>=1.10.0
+torchvision>=0.11.0
+numpy>=1.19.0
+pandas>=1.3.0
+Pillow>=8.0.0
+scikit-learn>=0.24.0
+tqdm>=4.60.0
+PyYAML>=5.4.0
+nystrom-attention>=0.0.11

scripts/evaluate.sh ADDED Viewed

	@@ -0,0 +1,6 @@

+#!/bin/bash
+# 评估脚本 - 在测试集上评估模型性能
+# 请先修改 config.yaml 中的数据路径
+cd "$(dirname "$0")/.."
+python evaluate.py

scripts/infer_single.sh ADDED Viewed

	@@ -0,0 +1,7 @@

+#!/bin/bash
+# 单步推理脚本 - 对单个病例进行推理
+# 用法1: ./infer_single.sh /path/to/image1.png /path/to/image2.png ...
+# 用法2: ./infer_single.sh --image_dir /path/to/case_folder/
+cd "$(dirname "$0")/.."
+python infer_single_case.py "$@" --threshold 0.5

scripts/train.sh ADDED Viewed

	@@ -0,0 +1,5 @@

+#!/bin/bash
+# 训练脚本 - TransMIL + Query2Label Hybrid Model
+# 请先修改 config.yaml 中的数据路径
+python train_hybrid.py --config config.yaml

thyroid_dataset.py ADDED Viewed

	@@ -0,0 +1,285 @@

+import os
+import json
+import torch
+import pandas as pd
+import numpy as np
+from PIL import Image
+from pathlib import Path
+from typing import List, Dict, Optional
+from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
+from torchvision import transforms
+# 18类标签定义 (必须与CSV列顺序严格一致)
+'''
+TARGET_CLASSES = [
+    "TI-RADS 1级", "TI-RADS 2级", "TI-RADS 3级", "TI-RADS 4a级",
+    "TI-RADS 4b级", "TI-RADS 4c级", "TI-RADS 5级",
+    "钙化", "甲亢", "囊肿", "淋巴结", "胶质潴留", "切除术后",
+    "弥漫性病变", "结节性甲状腺肿", "桥本氏甲状腺炎", "反应性", "转移性"
+]
+'''
+#17类标签定义，去除切除术后
+TARGET_CLASSES = [
+    "TI-RADS 1级", "TI-RADS 2级", "TI-RADS 3级", "TI-RADS 4a级",
+    "TI-RADS 4b级", "TI-RADS 4c级", "TI-RADS 5级",
+    "钙化", "甲亢", "囊肿", "淋巴结", "胶质潴留",
+    "弥漫性病变", "结节性甲状腺肿", "桥本氏甲状腺炎", "反应性", "转移性"
+]
+# 定义稀有/困难类别索引 (用于重采样)
+# 对应: 4b(4), 4c(5), 5(6), 切除(12), 转移(17)
+#RARE_CLASS_INDICES = [4, 5, 6, 12, 17]
+RARE_CLASS_INDICES = [4, 5, 6, 16] #17类标签
+class ThyroidMultiLabelDataset(Dataset):
+    def __init__(self,
+                 data_root: str,
+                 annotation_csv: str,
+                 split_json: Optional[str] = None,
+                 split_type: str = 'train',  # 'train', 'val', 'test'
+                 val_json_path: Optional[str] = None, # 仅当 split_type='train' 时需要，用于排除验证集
+                 test_json_path: Optional[str] = None, # 仅当 split_type='train' 时需要，用于排除测试集
+                 img_size: int = 224,
+                 max_images_per_case: int = 20,
+                 transform=None):
+        self.data_root = Path(data_root)
+        self.img_size = img_size
+        self.max_images_per_case = max_images_per_case
+        self.split_type = split_type
+        # 1. 读取所有标签
+        self.df_labels = pd.read_csv(annotation_csv)
+        # 将 case_path 设为索引，方便查询
+        self.df_labels.set_index('case_path', inplace=True)
+        # 2. 确定数据集包含的 case_list
+        self.case_list = self._get_split_cases(split_json, val_json_path, test_json_path)
+        # 3. 定义数据增强
+        if transform:
+            self.transform = transform
+        elif split_type == 'train':
+            self.transform = transforms.Compose([
+                transforms.Resize((img_size, img_size)),
+                transforms.RandomHorizontalFlip(p=0.5),
+                transforms.RandomVerticalFlip(p=0.5), # 超声可以上下翻转
+                transforms.RandomRotation(15),
+                transforms.ColorJitter(brightness=0.2, contrast=0.2),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ])
+        else:
+            self.transform = transforms.Compose([
+                transforms.Resize((img_size, img_size)),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ])
+        print(f"[{split_type.upper()}] Loaded {len(self.case_list)} cases.")
+    def _get_split_cases(self, split_json, val_json_path, test_json_path):
+        """
+        根据 JSON 文件划分数据集
+        """
+        all_cases_in_csv = set(self.df_labels.index.tolist())
+        # 读取指定的 split json (如果是 val 或 test)
+        target_cases = []
+        if split_json:
+            with open(split_json, 'r') as f:
+                data = json.load(f)
+                # JSON 里的 rel_path 对应 CSV 里的 case_path
+                target_cases = [item['rel_path'] for item in data]
+            # 过滤掉 CSV 里没有的 case (以防万一)
+            valid_cases = [c for c in target_cases if c in all_cases_in_csv]
+            return valid_cases
+        # 如果是 Train，逻辑是：所有 CSV 里的 case 减去 Val 和 Test 的 case
+        elif self.split_type == 'train':
+            exclude_cases = set()
+            if val_json_path:
+                with open(val_json_path, 'r') as f:
+                    exclude_cases.update([item['rel_path'] for item in json.load(f)])
+            if test_json_path:
+                with open(test_json_path, 'r') as f:
+                    exclude_cases.update([item['rel_path'] for item in json.load(f)])
+            train_cases = list(all_cases_in_csv - exclude_cases)
+            return sorted(train_cases) # 排序保证确定性
+        else:
+            return []
+    def __len__(self):
+        return len(self.case_list)
+    def __getitem__(self, idx):
+        case_rel_path = self.case_list[idx]
+        # 1. 拼接图片目录路径: data_root / BatchX/CaseID / Images
+        img_dir = self.data_root / case_rel_path / "Images"
+        # 2. 获取标签
+        # df.loc[index] 返回 Series，转 numpy
+        try:
+            label_vec = self.df_labels.loc[case_rel_path, TARGET_CLASSES].values.astype(np.float32)
+            label_tensor = torch.tensor(label_vec)
+        except KeyError:
+            print(f"Warning: Label for {case_rel_path} not found in CSV. Using zeros.")
+            label_tensor = torch.zeros(len(TARGET_CLASSES))
+        # 3. 读取图片
+        image_files = sorted(list(img_dir.glob("*.jpg")) + list(img_dir.glob("*.png")) + list(img_dir.glob("*.bmp")))
+        # 采样逻辑 (Train: 随机采; Val/Test: 取前N张)
+        if self.max_images_per_case and len(image_files) > self.max_images_per_case:
+            if self.split_type == 'train':
+                # 训练时随机采样，增加多样性
+                image_files = np.random.choice(image_files, self.max_images_per_case, replace=False)
+            else:
+                image_files = image_files[:self.max_images_per_case]
+        images = []
+        for img_path in image_files:
+            try:
+                img = Image.open(img_path).convert('RGB')
+                if self.transform:
+                    img = self.transform(img)
+                images.append(img)
+            except Exception as e:
+                pass
+        if len(images) == 0:
+            # 异常处理：生成全黑图
+            images = [torch.zeros(3, self.img_size, self.img_size)]
+        images_stack = torch.stack(images) # [N, 3, H, W]
+        return {
+            'images': images_stack,
+            'labels': label_tensor,
+            'num_images': len(images),
+            'case_id': case_rel_path
+        }
+    def get_sampler_weights(self):
+        """
+        计算采样权重：包含稀有类别的样本权重 = 10，其他 = 1
+        """
+        weights = []
+        for case_rel_path in self.case_list:
+            label_vec = self.df_labels.loc[case_rel_path, TARGET_CLASSES].values
+            # 检查是否有稀有类别
+            is_rare = False
+            for idx in RARE_CLASS_INDICES:
+                if label_vec[idx] == 1:
+                    is_rare = True
+                    break
+            if is_rare:
+                weights.append(10.0) # 稀有样本采样概率翻10倍
+            else:
+                weights.append(1.0)
+        return torch.tensor(weights, dtype=torch.double)
+def collate_fn(batch):
+    images_list = []
+    labels_list = []
+    num_instances_list = []
+    case_ids = []
+    for item in batch:
+        images_list.append(item['images'])
+        labels_list.append(item['labels'])
+        num_instances_list.append(item['num_images'])
+        case_ids.append(item['case_id'])
+    all_images = torch.cat(images_list, dim=0)
+    labels = torch.stack(labels_list)
+    num_instances_per_case = torch.tensor(num_instances_list, dtype=torch.long)
+    return {
+        'images': all_images,
+        'labels': labels,
+        'num_instances_per_case': num_instances_per_case,
+        'case_ids': case_ids
+    }
+def create_dataloaders(config):
+    data_root = config['data']['data_root']
+    csv_path = config['data']['annotation_csv']
+    val_json = config['data']['val_json']
+    test_json = config['data']['test_json']
+    # Train Dataset
+    train_dataset = ThyroidMultiLabelDataset(
+        data_root=data_root,
+        annotation_csv=csv_path,
+        split_type='train',
+        val_json_path=val_json,
+        test_json_path=test_json,
+        img_size=config['data']['img_size'],
+        max_images_per_case=config['data']['max_images_per_case']
+    )
+    # 计算采样权重并创建 Sampler
+    print("Calculating sampler weights for class balance...")
+    train_weights = train_dataset.get_sampler_weights()
+    sampler = WeightedRandomSampler(train_weights, len(train_weights))
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=config['training']['batch_size'],
+        sampler=sampler, # 使用 sampler 时不要 shuffle=True
+        num_workers=config['data']['num_workers'],
+        collate_fn=collate_fn,
+        pin_memory=True,
+        drop_last=True
+    )
+    # Val Dataset
+    val_dataset = ThyroidMultiLabelDataset(
+        data_root=data_root,
+        annotation_csv=csv_path,
+        split_type='val',
+        split_json=val_json,
+        img_size=config['data']['img_size'],
+        max_images_per_case=config['data']['max_images_per_case']
+    )
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=config['training']['batch_size'],
+        shuffle=False,
+        num_workers=config['data']['num_workers'],
+        collate_fn=collate_fn,
+        pin_memory=True
+    )
+    # Test Dataset
+    test_dataset = ThyroidMultiLabelDataset(
+        data_root=data_root,
+        annotation_csv=csv_path,
+        split_type='test',
+        split_json=test_json,
+        img_size=config['data']['img_size'],
+        max_images_per_case=None # 测试时尽可能用所有图
+    )
+    test_loader = DataLoader(
+        test_dataset,
+        batch_size=config['training']['batch_size'],
+        shuffle=False,
+        num_workers=config['data']['num_workers'],
+        collate_fn=collate_fn,
+        pin_memory=True
+    )
+    return train_loader, val_loader, test_loader

thyroid_multilabel_annotations.csv ADDED Viewed

The diff for this file is too large to render. See raw diff

train_hybrid.py ADDED Viewed

	@@ -0,0 +1,439 @@

+"""
+Training Script for TransMIL + Query2Label Hybrid Model
+Supports:
+- End-to-end training with ResNet-50 backbone
+- Mixed precision training (AMP) for memory efficiency
+- Gradient accumulation for larger effective batch size
+- Gradient checkpointing for ResNet-50
+- AsymmetricLoss for multi-label imbalance
+- Multi-label evaluation metrics (mAP, per-class AP, F1)
+"""
+import sys
+#sys.path.append('query2labels/lib/models')
+#sys.path.append('/XYFS01/HDD_POOL/sysu_gbli2/sysu_gbli2xy_1/chenshiyu/ThyroidAgent/ThyroidRegion/HintsVer3/query2labels/lib/')
+import os
+import argparse
+import yaml
+from pathlib import Path
+from datetime import datetime
+import json
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.cuda.amp import autocast, GradScaler
+from torch.utils.tensorboard import SummaryWriter
+import numpy as np
+from tqdm import tqdm
+from sklearn.metrics import average_precision_score, f1_score
+# Import model and dataset
+from models.transmil_q2l import TransMIL_Query2Label_E2E
+from thyroid_dataset import create_dataloaders
+# Import AsymmetricLoss
+try:
+    from models.aslloss import AsymmetricLossOptimized
+except ImportError:
+    print("Warning: Could not import AsymmetricLoss.")
+    AsymmetricLossOptimized = None
+'''
+try:
+    #from aslloss import AsymmetricLossOptimized
+    from models.aslloss import AsymmetricLossOptimized
+except ImportError:
+    print("Warning: Could not import AsymmetricLoss from query2labels.")
+    print("Make sure query2labels/lib/models/aslloss.py is in Python path.")
+    AsymmetricLossOptimized = None
+'''
+# ============================================================================
+# Metrics
+# ============================================================================
+def compute_multilabel_metrics(preds, targets, threshold=0.5):
+    """
+    Compute multi-label classification metrics.
+    Args:
+        preds: [N, num_class] numpy array of probabilities
+        targets: [N, num_class] numpy array of binary labels
+        threshold: Classification threshold for F1 score
+    Returns:
+        dict with mAP, per-class AP, F1 scores
+    """
+    metrics = {}
+    # Mean Average Precision (mAP)
+    aps = []
+    for i in range(targets.shape[1]):
+        if targets[:, i].sum() > 0:  # Skip classes with no positive samples
+            ap = average_precision_score(targets[:, i], preds[:, i])
+            aps.append(ap)
+        else:
+            aps.append(np.nan)
+    metrics['mAP'] = np.nanmean(aps)
+    metrics['per_class_AP'] = aps
+    # F1 Score at threshold
+    preds_binary = (preds >= threshold).astype(int)
+    f1_micro = f1_score(targets, preds_binary, average='micro', zero_division=0)
+    f1_macro = f1_score(targets, preds_binary, average='macro', zero_division=0)
+    f1_samples = f1_score(targets, preds_binary, average='samples', zero_division=0)
+    metrics['F1_micro'] = f1_micro
+    metrics['F1_macro'] = f1_macro
+    metrics['F1_samples'] = f1_samples
+    return metrics
+# ============================================================================
+# Training Functions
+# ============================================================================
+def train_epoch(model, dataloader, criterion, optimizer, scaler, device, config, epoch):
+    """
+    Train for one epoch with gradient accumulation and mixed precision.
+    Args:
+        model: TransMIL_Query2Label_E2E model
+        dataloader: Training dataloader
+        criterion: AsymmetricLoss
+        optimizer: AdamW optimizer
+        scaler: GradScaler for AMP
+        device: torch.device
+        config: Config dict
+        epoch: Current epoch number
+    Returns:
+        Average loss for epoch
+    """
+    model.train()
+    total_loss = 0.0
+    accumulation_steps = config['training']['gradient_accumulation_steps']
+    use_amp = config['training']['use_amp']
+    # Progress bar
+    pbar = tqdm(dataloader, desc=f"Epoch {epoch}")
+    optimizer.zero_grad()
+    for i, batch in enumerate(pbar):
+        images = batch['images'].to(device)  # [B*N_total, 3, H, W]
+        labels = batch['labels'].to(device)  # [B, num_class]
+        num_instances_per_case = batch['num_instances_per_case']  # [B]
+        # Mixed precision forward pass
+        if use_amp:
+            with autocast():
+                logits = model(images, num_instances_per_case)
+                loss = criterion(logits, labels)
+                loss = loss / accumulation_steps  # Scale loss for accumulation
+        else:
+            logits = model(images, num_instances_per_case)
+            loss = criterion(logits, labels)
+            loss = loss / accumulation_steps
+        # Backward pass
+        if use_amp:
+            scaler.scale(loss).backward()
+        else:
+            loss.backward()
+        # Optimizer step every accumulation_steps
+        if (i + 1) % accumulation_steps == 0:
+            if use_amp:
+                scaler.step(optimizer)
+                scaler.update()
+            else:
+                optimizer.step()
+            optimizer.zero_grad()
+        # Track loss
+        total_loss += loss.item() * accumulation_steps
+        pbar.set_postfix({'loss': loss.item() * accumulation_steps})
+    return total_loss / len(dataloader)
+@torch.no_grad()
+def validate(model, dataloader, criterion, device, config):
+    """
+    Validate model with multi-label metrics.
+    Args:
+        model: TransMIL_Query2Label_E2E model
+        dataloader: Validation dataloader
+        criterion: AsymmetricLoss
+        device: torch.device
+        config: Config dict
+    Returns:
+        dict with loss and metrics (mAP, F1, etc.)
+    """
+    model.eval()
+    total_loss = 0.0
+    all_preds = []
+    all_targets = []
+    for batch in tqdm(dataloader, desc="Validating"):
+        images = batch['images'].to(device)
+        labels = batch['labels'].to(device)
+        num_instances_per_case = batch['num_instances_per_case']
+        # Forward pass
+        logits = model(images, num_instances_per_case)
+        loss = criterion(logits, labels)
+        # Sigmoid for multi-label probabilities
+        preds = torch.sigmoid(logits)
+        # Store predictions and targets
+        all_preds.append(preds.cpu().numpy())
+        all_targets.append(labels.cpu().numpy())
+        total_loss += loss.item()
+    # Concatenate all batches
+    all_preds = np.concatenate(all_preds, axis=0)
+    all_targets = np.concatenate(all_targets, axis=0)
+    # Compute metrics
+    metrics = compute_multilabel_metrics(all_preds, all_targets)
+    metrics['loss'] = total_loss / len(dataloader)
+    return metrics
+# ============================================================================
+# Main Training Loop
+# ============================================================================
+def train(config, resume_from=None):
+    """
+    Main training function.
+    Args:
+        config: Config dictionary from YAML
+        resume_from: Optional checkpoint path to resume training
+    """
+    # Setup device
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"\nUsing device: {device}")
+    if torch.cuda.is_available():
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")
+    # Create save directory
+    save_dir = Path(config['training']['save_dir'])
+    save_dir.mkdir(parents=True, exist_ok=True)
+    # Create tensorboard writer
+    log_dir = save_dir / 'logs' / datetime.now().strftime('%Y%m%d_%H%M%S')
+    writer = SummaryWriter(log_dir)
+    # Save config
+    with open(save_dir / 'config.yaml', 'w') as f:
+        yaml.dump(config, f)
+    # Create dataloaders
+    print("\nCreating dataloaders...")
+    train_loader, val_loader, test_loader = create_dataloaders(config)
+    # Create model
+    print("\nCreating model...")
+    model = TransMIL_Query2Label_E2E(
+        num_class=config['model']['num_class'],
+        hidden_dim=config['model']['hidden_dim'],
+        nheads=config['model']['nheads'],
+        num_decoder_layers=config['model']['num_decoder_layers'],
+        pretrained_resnet=config['model']['pretrained_resnet'],
+        use_checkpointing=config['training']['gradient_checkpointing'],
+        use_ppeg=config['model'].get('use_ppeg', False)
+    )
+    model = model.to(device)
+    # Print model stats
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+    # Create optimizer
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=config['training']['lr'],
+        weight_decay=config['training']['weight_decay']
+    )
+    # Create scheduler
+    scheduler_type = config['training'].get('scheduler', 'cosine')
+    if scheduler_type == 'cosine':
+        scheduler = optim.lr_scheduler.CosineAnnealingLR(
+            optimizer,
+            T_max=config['training']['epochs'],
+            eta_min=1e-6
+        )
+    elif scheduler_type == 'onecycle':
+        scheduler = optim.lr_scheduler.OneCycleLR(
+            optimizer,
+            max_lr=config['training']['lr'],
+            epochs=config['training']['epochs'],
+            steps_per_epoch=len(train_loader)
+        )
+    else:
+        scheduler = None
+    # Create loss function
+    if AsymmetricLossOptimized is not None:
+        criterion = AsymmetricLossOptimized(
+            gamma_neg=config['training']['gamma_neg'],
+            gamma_pos=config['training']['gamma_pos'],
+            clip=config['training']['clip'],
+            eps=1e-5
+        )
+    else:
+        # Fallback to BCEWithLogitsLoss
+        print("Warning: Using BCEWithLogitsLoss instead of AsymmetricLoss")
+        criterion = nn.BCEWithLogitsLoss()
+    # Mixed precision scaler
+    scaler = GradScaler() if config['training']['use_amp'] else None
+    # Resume from checkpoint if specified
+    start_epoch = 0
+    best_map = 0.0
+    if resume_from is not None and Path(resume_from).exists():
+        print(f"\nResuming from {resume_from}")
+        checkpoint = torch.load(resume_from, map_location=device)
+        model.load_state_dict(checkpoint['model_state_dict'])
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+        start_epoch = checkpoint['epoch'] + 1
+        best_map = checkpoint.get('best_map', 0.0)
+        if scheduler is not None and 'scheduler_state_dict' in checkpoint:
+            scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
+        print(f"Resumed from epoch {start_epoch}, best mAP: {best_map:.4f}")
+    # Training loop
+    print(f"\nStarting training for {config['training']['epochs']} epochs...")
+    print("="*80)
+    for epoch in range(start_epoch, config['training']['epochs']):
+        # Train
+        train_loss = train_epoch(model, train_loader, criterion, optimizer, scaler, device, config, epoch)
+        # Validate
+        val_metrics = validate(model, val_loader, criterion, device, config)
+        # Update scheduler
+        if scheduler is not None:
+            if scheduler_type == 'onecycle':
+                pass  # OneCycleLR updates per step, not per epoch
+            else:
+                scheduler.step()
+        # Log metrics
+        current_lr = optimizer.param_groups[0]['lr']
+        writer.add_scalar('Loss/train', train_loss, epoch)
+        writer.add_scalar('Loss/val', val_metrics['loss'], epoch)
+        writer.add_scalar('Metrics/mAP', val_metrics['mAP'], epoch)
+        writer.add_scalar('Metrics/F1_micro', val_metrics['F1_micro'], epoch)
+        writer.add_scalar('Metrics/F1_macro', val_metrics['F1_macro'], epoch)
+        writer.add_scalar('LR', current_lr, epoch)
+        # Print epoch summary
+        print(f"\nEpoch {epoch}/{config['training']['epochs']}")
+        print(f"  Train Loss: {train_loss:.4f}")
+        print(f"  Val Loss: {val_metrics['loss']:.4f}")
+        print(f"  mAP: {val_metrics['mAP']:.4f}")
+        print(f"  F1 (micro): {val_metrics['F1_micro']:.4f}")
+        print(f"  F1 (macro): {val_metrics['F1_macro']:.4f}")
+        print(f"  LR: {current_lr:.6f}")
+        # Save checkpoint
+        is_best = val_metrics['mAP'] > best_map
+        if is_best:
+            best_map = val_metrics['mAP']
+        if (epoch + 1) % config['training']['save_freq'] == 0 or is_best:
+            checkpoint = {
+                'epoch': epoch,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict() if scheduler is not None else None,
+                'train_loss': train_loss,
+                'val_metrics': val_metrics,
+                'best_map': best_map,
+                'config': config
+            }
+            # Save latest checkpoint
+            torch.save(checkpoint, save_dir / 'checkpoint_latest.pth')
+            # Save best checkpoint
+            if is_best:
+                torch.save(checkpoint, save_dir / 'checkpoint_best.pth')
+                print(f"  ✓ Saved best model (mAP: {best_map:.4f})")
+            # Save periodic checkpoint
+            if (epoch + 1) % config['training']['save_freq'] == 0:
+                torch.save(checkpoint, save_dir / f'checkpoint_epoch_{epoch}.pth')
+    print("\n" + "="*80)
+    print(f"Training completed! Best mAP: {best_map:.4f}")
+    print(f"Checkpoints saved to: {save_dir}")
+    writer.close()
+    # Final test evaluation
+    print("\nEvaluating on test set...")
+    test_metrics = validate(model, test_loader, criterion, device, config)
+    print(f"\nTest Results:")
+    print(f"  mAP: {test_metrics['mAP']:.4f}")
+    print(f"  F1 (micro): {test_metrics['F1_micro']:.4f}")
+    print(f"  F1 (macro): {test_metrics['F1_macro']:.4f}")
+    # Save test results
+    with open(save_dir / 'test_results.json', 'w') as f:
+        json.dump({k: float(v) if not isinstance(v, list) else v
+                   for k, v in test_metrics.items()}, f, indent=2)
+# ============================================================================
+# Main
+# ============================================================================
+def main():
+    parser = argparse.ArgumentParser(description='Train TransMIL + Query2Label Hybrid Model')
+    parser.add_argument('--config', type=str, default='hybrid_model/config.yaml',
+                        help='Path to config file')
+    parser.add_argument('--resume', type=str, default=None,
+                        help='Path to checkpoint to resume from')
+    args = parser.parse_args()
+    # Load config
+    with open(args.config, 'r') as f:
+        config = yaml.safe_load(f)
+    print("="*80)
+    print("TransMIL + Query2Label Hybrid Model Training")
+    print("="*80)
+    print(f"\nConfig: {args.config}")
+    if args.resume:
+        print(f"Resume from: {args.resume}")
+    # Train
+    train(config, resume_from=args.resume)
+if __name__ == "__main__":
+    main()