Upload paligemma_dataset.py with huggingface_hub

paligemma_dataset.py

@@ -1,16 +1,14 @@
 import json
 import os
-from pathlib import Path
-
 import datasets
-from PIL import Image
+
 import jsonlines
 
 logger = datasets.logging.get_logger(__name__)
 
 _CITATION = """\
-@misc{chen2024paligemma,
-  title={PaliGemma Multitask Dataset},
+@misc{chen2024gpradar,
+  title={GPRadar-Defect-MultiTask Dataset},
   author={Chen, Xingqiang},
   year={2024},
   publisher={Hugging Face}
@@ -18,16 +16,18 @@ _CITATION = """\
 """
 
 _DESCRIPTION = """\
-This dataset contains images and annotations for defect detection and analysis,
-designed for training and evaluating the PaliGemma multitask model.
+GPRadar-Defect-MultiTask Dataset
+
+This dataset contains ground penetrating radar (GPR) images and annotations for defect detection and analysis,
+designed for training and evaluating multimodal models for GPR defect detection.
 The dataset includes both basic defect detection samples and a larger set of
-874 annotated images from real-world structural inspections.
+874 annotated images from real-world structural inspections focusing on voids and cracks.
 """
 
-_HOMEPAGE = "https://huggingface.co/datasets/xingqiang/paligemma-multitask-dataset"
+_HOMEPAGE = "https://huggingface.co/datasets/xingqiang/GPRadar-Defect-MultiTask"
 
 class PaligemmaDataset(datasets.GeneratorBasedBuilder):
-    """PaliGemma Multitask Dataset for defect detection and analysis."""
+    """GPRadar-Defect-MultiTask Dataset for GPR defect detection and analysis."""
 
     VERSION = datasets.Version("1.1.0")
 
@@ -39,7 +39,6 @@ class PaligemmaDataset(datasets.GeneratorBasedBuilder):
                 "boxes": datasets.Sequence(datasets.Sequence(datasets.Value("float32"), length=4)),
                 "labels": datasets.Sequence(datasets.ClassLabel(names=["void", "crack"])),
                 "caption": datasets.Value("string"),
-                "source": datasets.Value("string"),
             }),
             supervised_keys=None,
             homepage=_HOMEPAGE,
@@ -70,121 +69,54 @@ class PaligemmaDataset(datasets.GeneratorBasedBuilder):
         ]
 
     def _generate_examples(self, split):
-        """生成示例。"""
-        # 优先加载统一格式的注释
-        unified_path = os.path.join("annotations", f"{split}_unified.json")
-        if os.path.exists(unified_path):
-            logger.info(f"使用统一格式的注释文件: {unified_path}")
-            with open(unified_path, encoding="utf-8") as f:
-                annotations = json.load(f)
-                for idx, ann in enumerate(annotations):
-                    image_path = os.path.join("images", split, ann["image_filename"])
-                    try:
-                        yield f"unified_{idx}", {
-                            "image": image_path,
-                            "boxes": ann["boxes"],
-                            "labels": ann["labels"],
-                            "caption": ann["caption"],
-                            "source": ann.get("source", "unified")
-                        }
-                    except Exception as e:
-                        logger.warning(f"跳过无效图像 {image_path}: {e}")
-                        continue
-            return  # 如果使用了统一格式，不再处理其他格式
+        """Yields examples."""
+        # 统一格式的注释文件
+        annotation_file = f"annotations/{split}_unified.json"
         
-        # 如果没有统一格式，则回退到原始格式
-        # 加载原始 JSON 注释
-        json_path = os.path.join("annotations", f"{split}.json")
-        if os.path.exists(json_path):
-            with open(json_path, encoding="utf-8") as f:
-                annotations = json.load(f)
-                for idx, ann in enumerate(annotations):
-                    image_path = os.path.join("images", split, ann["image_filename"])
-                    try:
-                        # 不要尝试在这里打开图像，只返回路径
-                        yield f"orig_{idx}", {
-                            "image": image_path,
-                            "boxes": ann["boxes"],
-                            "labels": ann["labels"],
-                            "caption": ann["caption"],
-                            "source": "original"
-                        }
-                    except Exception as e:
-                        logger.warning(f"跳过无效图像 {image_path}: {e}")
-                        continue
+        if not os.path.exists(annotation_file):
+            # 如果统一格式文件不存在，尝试转换
+            convert_annotations_to_unified_format()
+            
+            # 再次检查文件是否已创建
+            if not os.path.exists(annotation_file):
+                logger.warning(f"找不到统一格式注释文件: {annotation_file}，将返回空数据")
+                return
+
+        # 加载统一格式的注释
+        with open(annotation_file, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+
+        for idx, ann in enumerate(annotations):
+            # 尝试在不同的可能路径中查找图���
+            image_found = False
+            image_filename = ann["image_filename"]
+            
+            for image_path in [
+                f"images/{split}/{image_filename}",
+                f"images/datasets/{image_filename}",
+                f"images/{image_filename}",
+            ]:
+                if os.path.exists(image_path):
+                    yield idx, {
+                        "image": image_path,
+                        "boxes": ann["boxes"],
+                        "labels": ann["labels"],
+                        "caption": ann["caption"],
+                    }
+                    image_found = True
+                    break
+            
+            if not image_found:
+                logger.warning(f"找不到图像文件: {image_filename}，跳过该示例")
+
+
+def normalize_image_path(image_path):
+    """规范化图像路径，移除多余的前缀"""
+    # 处理特殊前缀
+    if "p-1.v1i.paligemma-multimodal/dataset/" in image_path:
+        return image_path.split("p-1.v1i.paligemma-multimodal/dataset/")[-1]
+    return image_path
 
-        # 加载 JSONL 注释
-        jsonl_path = os.path.join("annotations", f"_annotations.{split}.jsonl")
-        if os.path.exists(jsonl_path):
-            with jsonlines.open(jsonl_path) as reader:
-                for idx, ann in enumerate(reader):
-                    # 确保使用正确的图像文件名
-                    image_filename = ann.get("image", "")
-                    image_path = os.path.join("images", split, image_filename)
-                    
-                    try:
-                        # 不要尝试在这里打开图像，只返回路径
-                        # 转换注释为我们的格式
-                        if "annotations" in ann:
-                            # 处理新格式
-                            boxes = [[b["x"], b["y"], b["width"], b["height"]] for b in ann["annotations"]]
-                            labels = [0 if b["class"] == "void" else 1 for b in ann["annotations"]]
-                            caption = f"Image contains {len(boxes)} defects: " + \
-                                    ", ".join([b["class"] for b in ann["annotations"]])
-                        else:
-                            # 处理旧格式 (prefix/suffix)
-                            # 这里需要解析 suffix 中的位置信息
-                            boxes = []
-                            labels = []
-                            if "suffix" in ann:
-                                parts = ann["suffix"].split(";")
-                                for part in parts:
-                                    part = part.strip()
-                                    if "<loc" in part:
-                                        # 解析位置和标签
-                                        loc_parts = part.split()
-                                        if len(loc_parts) >= 2:
-                                            # 提取坐标
-                                            coords = []
-                                            for loc in loc_parts[0].split("><"):
-                                                if loc.startswith("<loc"):
-                                                    coords.append(int(loc[4:-1]) / 1024)  # 归一化坐标
-                                            
-                                            if len(coords) == 4:
-                                                boxes.append(coords)
-                                                label = 0 if "void" in loc_parts[1] else 1
-                                                labels.append(label)
-                        
-                            caption = ann.get("prefix", "")
-                        
-                        # 检查图像是否存在
-                        image_exists = False
-                        
-                        # 检查images/datasets目录
-                        if os.path.exists(f"images/datasets/{image_filename}"):
-                            image_exists = True
-                            
-                        # 检查原始路径
-                        if not image_exists:
-                            for img_split in ["train", "val", "test"]:
-                                if os.path.exists(f"images/{img_split}/{image_filename}"):
-                                    image_exists = True
-                                    break
-                        
-                        if not image_exists:
-                            print(f"警告: 图像文件不存在: {image_filename}")
-                            continue
-                        
-                        yield f"p1v1_{idx}", {
-                            "image": image_path,
-                            "boxes": boxes,
-                            "labels": labels,
-                            "caption": caption,
-                            "source": "p1v1"
-                        }
-                    except Exception as e:
-                        logger.warning(f"跳过��效注释 {image_path}: {e}")
-                        continue
 
 def convert_annotations_to_unified_format():
     """将所有注释转换为统一格式"""
@@ -220,21 +152,29 @@ def convert_annotations_to_unified_format():
         else:
             print(f"未找到 JSON 文件: {json_path}")
         
-        # 处理 JSONL 注释，包括目录p-1.v1i.paligemma下的文件
-        jsonl_variants = [
+        # 查找所有可能的JSONL注释文件
+        # 1. 检查根目录
+        jsonl_files_to_check = [
             f"_annotations.{split}.jsonl", 
-            f"_annotations.{split}1.jsonl",
-            f"p-1.v1i.paligemma/_annotations.{split}.jsonl",
-            f"p-1.v1i.paligemma/_annotations.{split}1.jsonl"
+            f"_annotations.{split}1.jsonl"
         ]
         
-        for jsonl_variant in jsonl_variants:
-            jsonl_path = f"annotations/{jsonl_variant}"
-            print(f"检查 JSONL 文件: {jsonl_path}")
-            if os.path.exists(jsonl_path):
-                print(f"找到 JSONL 文件: {jsonl_path}")
+        # 2. 递归查找子目录中的JSONL文件
+        for root, dirs, files in os.walk("annotations"):
+            for file in files:
+                if file.endswith(f"{split}.jsonl") or file.endswith(f"{split}1.jsonl") or file.endswith(f"{split}2.jsonl"):
+                    rel_path = os.path.relpath(os.path.join(root, file), "annotations")
+                    if rel_path != file:  # 不是根目录的文件
+                        jsonl_files_to_check.append(rel_path)
+        
+        # 处理所有找到的JSONL文件
+        for jsonl_path in jsonl_files_to_check:
+            full_path = os.path.join("annotations", jsonl_path)
+            print(f"检查 JSONL 文件: {full_path}")
+            if os.path.exists(full_path):
+                print(f"找到 JSONL 文件: {full_path}")
                 annotation_count = 0
-                with open(jsonl_path, encoding="utf-8") as f:
+                with open(full_path, encoding="utf-8") as f:
                     for line_num, line in enumerate(f, 1):
                         try:
                             line = line.strip()
@@ -248,20 +188,24 @@ def convert_annotations_to_unified_format():
                             if not image_filename:
                                 print(f"跳过第 {line_num} 行: 没有图像文件名")
                                 continue
+                            
+                            # 规范化图像路径
+                            image_filename = normalize_image_path(image_filename)
                                 
                             # 检查图像是否存在
                             image_exists = False
+                            possible_image_paths = [
+                                f"images/datasets/{image_filename}",
+                                f"images/train/{image_filename}",
+                                f"images/val/{image_filename}",
+                                f"images/test/{image_filename}",
+                                f"images/{image_filename}"  # 直接在images目录下
+                            ]
                             
-                            # 检查images/datasets目录
-                            if os.path.exists(f"images/datasets/{image_filename}"):
-                                image_exists = True
-                                
-                            # 检查原始路径
-                            if not image_exists:
-                                for img_split in ["train", "val", "test"]:
-                                    if os.path.exists(f"images/{img_split}/{image_filename}"):
-                                        image_exists = True
-                                        break
+                            for img_path in possible_image_paths:
+                                if os.path.exists(img_path):
+                                    image_exists = True
+                                    break
                             
                             if not image_exists:
                                 print(f"警告: 图像文件不存在: {image_filename}")
@@ -281,26 +225,39 @@ def convert_annotations_to_unified_format():
                                 caption = ann.get("prefix", "")
                                 
                                 if "suffix" in ann:
-                                    parts = ann["suffix"].split(";")
-                                    for part in parts:
-                                        part = part.strip()
+                                    parts = ann["suffix"].split()
+                                    for i, part in enumerate(parts):
                                         if "<loc" in part:
-                                            # 解析位置和标签
-                                            loc_parts = part.split()
-                                            if len(loc_parts) >= 2:
-                                                # 提取坐标
-                                                coords = []
-                                                for loc in loc_parts[0].split("><"):
-                                                    if loc.startswith("<loc"):
-                                                        try:
-                                                            coords.append(int(loc[4:-1]) / 1024)  # 归一化坐标
-                                                        except ValueError:
-                                                            continue
+                                            # 解析位置
+                                            coords = []
+                                            loc_str = part
+                                            while loc_str.startswith("<loc") and len(coords) < 4:
+                                                try:
+                                                    # 提取坐标
+                                                    coord_value = int(loc_str[4:loc_str.find(">")])
+                                                    coords.append(coord_value / 1024)  # 归一化坐标
+                                                    # 移除已处理的部分
+                                                    loc_str = loc_str[loc_str.find(">")+1:]
+                                                except (ValueError, IndexError):
+                                                    break
+                                            
+                                            if len(coords) == 4:
+                                                boxes.append(coords)
+                                                # 查找标签（通常在下一个部分）
+                                                label_idx = 1
+                                                while i + label_idx < len(parts) and not parts[i + label_idx].startswith("<loc"):
+                                                    label_text = parts[i + label_idx]
+                                                    if "void" in label_text:
+                                                        labels.append(0)
+                                                        break
+                                                    elif "crack" in label_text:
+                                                        labels.append(1)
+                                                        break
+                                                    label_idx += 1
                                                 
-                                                if len(coords) == 4:
-                                                    boxes.append(coords)
-                                                    label = 0 if "void" in loc_parts[1] else 1
-                                                    labels.append(label)
+                                                # 如果未找到特定标签，默认为void
+                                                if len(labels) < len(boxes):
+                                                    labels.append(0)
                             
                             unified_annotations.append({
                                 "image_filename": image_filename,
@@ -311,22 +268,33 @@ def convert_annotations_to_unified_format():
                             })
                             annotation_count += 1
                         except json.JSONDecodeError as e:
-                            print(f"警告: {jsonl_path} 第 {line_num} 行不是有效的 JSON: {e}")
+                            print(f"警告: {full_path} 第 {line_num} 行不是有效的 JSON: {e}")
                             continue
-                print(f"从 {jsonl_path} 加载了 {annotation_count} 条注释")
+                print(f"从 {full_path} 加载了 {annotation_count} 条注释")
             else:
-                print(f"未找到 JSONL 文件: {jsonl_path}")
+                print(f"未找到 JSONL 文件: {full_path}")
         
         # 如果是valid分割，与val合并
-        if split == "valid" and os.path.exists(f"annotations/val_unified.json"):
-            try:
-                with open(f"annotations/val_unified.json", "r", encoding="utf-8") as f:
-                    val_annotations = json.load(f)
-                unified_annotations.extend(val_annotations)
-                print(f"将valid分割与val分割合并，共 {len(unified_annotations)} 条记录")
-            except Exception as e:
-                print(f"合并valid和val分割时出错: {e}")
-                
+        if split == "valid":
+            val_annotations = []
+            if os.path.exists(f"annotations/val_unified.json"):
+                try:
+                    with open(f"annotations/val_unified.json", "r", encoding="utf-8") as f:
+                        val_annotations = json.load(f)
+                    print(f"加载现有val分割注释，共 {len(val_annotations)} 条记录")
+                    
+                    # 合并注释，避免重复
+                    existing_filenames = {ann["image_filename"] for ann in val_annotations}
+                    for ann in unified_annotations:
+                        if ann["image_filename"] not in existing_filenames:
+                            val_annotations.append(ann)
+                            existing_filenames.add(ann["image_filename"])
+                    
+                    print(f"将valid分割与val分割合并，共 {len(val_annotations)} 条记录")
+                    unified_annotations = val_annotations
+                except Exception as e:
+                    print(f"合并valid和val分割时出错: {e}")
+                    
         # 保存统一格式的注释
         if unified_annotations:
             # 对于valid分割，保存为val_unified.json