test new custom dataset loader for streaming

dataset.py

@@ -1,176 +1,52 @@
 
 import os
-import json
 import datasets
-import rasterio
-from datetime import datetime
-from tqdm import tqdm
-
-class SSL4EOEUForest(datasets.GeneratorBasedBuilder):
-    """
-    SSL4EO-EU Forest Dataset Loader
-
-    This loader supports both directory-based scanning and prebuilt index streaming via JSONL.
-    It yields one sample at a time, making it compatible with Hugging Face's streaming mode.
-
-    Each sample includes:
-    - A list of image paths (one per timestamp)
-    - A single mask path
-    - Start and end timestamps for each image
-    - Sentinel tile IDs
-    - Bounding box metadata
-
-    Bounding boxes are stored as a dictionary of arrays:
-        {
-            "minx": [...], "maxx": [...], "miny": [...], "maxy": [...]
-        }
-
-    This avoids redundancy and simplifies downstream parsing.
-    """
 
+class MyDataset(datasets.GeneratorBasedBuilder):
     def _info(self):
         return datasets.DatasetInfo(
-            description="SSL4EO-EU Forest dataset with grouped timestamps and bounding box metadata.",
             features=datasets.Features({
-                "image_paths": datasets.Sequence(datasets.Value("string")),
-                "mask_path": datasets.Value("string"),
-                "start_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
-                "end_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
-                "sentinel_tile_ids": datasets.Sequence(datasets.Value("string")),
-                "bboxes": datasets.Features({
-                    "minx": datasets.Sequence(datasets.Value("float32")),
-                    "maxx": datasets.Sequence(datasets.Value("float32")),
-                    "miny": datasets.Sequence(datasets.Value("float32")),
-                    "maxy": datasets.Sequence(datasets.Value("float32")),
-                })
+                "sample_id": datasets.Value("string"),
+                "image": datasets.Image(),  # or datasets.Value("string") if you want paths
+                "mask": datasets.Image(),
             }),
-            citation="""@misc{ssl4eo_eu_forest,
-  author = {Nassim Ait Ali Braham and Conrad M Albrecht},
-  title = {SSL4EO-EU Forest Dataset},
-  year = {2025},
-  howpublished = {https://huggingface.co/datasets/dm4eo/ssl4eo-eu-forest},
-  note = {Funded by the EvoLand project under EU Horizon Europe grant No. 101082130.}
-}""",
-            homepage="https://www.evo-land.eu",
-            license="CC-BY-4.0",
         )
 
     def _split_generators(self, dl_manager):
-        use_index = os.environ.get("HF_DATASET_USE_INDEX", "false").lower() == "true"
-        use_local = os.environ.get("HF_DATASET_LOCAL", "false").lower() == "true"
-        root = os.path.abspath(".") if use_local else dl_manager.download_and_extract(".")
-
-        if use_index:
-            index_path = os.path.join(root, "index.jsonl")
-            return [datasets.SplitGenerator(name="all", gen_kwargs={"index_path": index_path})]
-        else:
-            images_dir = os.path.join(root, "images")
-            masks_dir = os.path.join(root, "masks")
-            return [datasets.SplitGenerator(name="all", gen_kwargs={
-                "images_dir": images_dir,
-                "masks_dir": masks_dir
-            })]
-
-    def _generate_examples(self, index_path=None, images_dir=None, masks_dir=None):
-        if index_path:
-            with open(index_path, "r") as f:
-                for key, line in enumerate(f):
-                    entry = json.loads(line)
-                    entry["start_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["start_timestamps"]]
-                    entry["end_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["end_timestamps"]]
-                    yield key, entry
-        else:
-            sample_ids = sorted(os.listdir(images_dir))
-            key = 0
-            for sample_id in sample_ids:
-                sample = self._parse_sample(sample_id, images_dir, masks_dir)
-                if sample:
-                    yield key, sample
-                    key += 1
-
-    @staticmethod
-    def _parse_sample(sample_id, images_dir, masks_dir):
-        """
-        Parses a single sample directory and returns a dictionary with all metadata.
-
-        Returns None if the sample is incomplete or malformed.
-        """
-        sample_path = os.path.join(images_dir, sample_id)
-        if not os.path.isdir(sample_path):
-            return None
-
-        mask_path = os.path.join(masks_dir, sample_id, "mask.tif")
-        if not os.path.exists(mask_path):
-            return None
-
-        image_paths, start_ts, end_ts, tile_ids = [], [], [], []
-        minx_list, maxx_list, miny_list, maxy_list = [], [], [], []
-
-        for ts in sorted(os.listdir(sample_path)):
-            parts = ts.split("_")
-            if len(parts) != 3:
-                continue
-            try:
-                start = datetime.strptime(parts[0], "%Y%m%dT%H%M%S")
-                end = datetime.strptime(parts[1], "%Y%m%dT%H%M%S")
-            except ValueError:
+        # Streaming mode: use iter_files to avoid downloading everything
+        image_paths = dl_manager.iter_files("images")
+        mask_paths = dl_manager.iter_files("masks")
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "image_paths": image_paths,
+                    "mask_paths": mask_paths,
+                }
+            )
+        ]
+
+    def _generate_examples(self, image_paths, mask_paths):
+        # Build a lookup for masks
+        mask_lookup = {}
+        for mask_path in mask_paths:
+            sample_id = os.path.basename(os.path.dirname(mask_path))
+            mask_lookup[sample_id] = mask_path
+
+        # Iterate over image folders
+        for image_path in image_paths:
+            if not image_path.endswith("all_bands.tif"):
                 continue
 
-            tile_id = parts[2]
-            image_path = os.path.join(sample_path, ts, "all_bands.tif")
-            if not os.path.exists(image_path):
-                continue
+            parts = image_path.split("/")
+            sample_id = parts[-3]  # e.g., "0000005"
 
-            try:
-                with rasterio.open(image_path) as src:
-                    bounds = src.bounds
-            except Exception:
+            if sample_id not in mask_lookup:
                 continue
 
-            image_paths.append(image_path)
-            start_ts.append(start)
-            end_ts.append(end)
-            tile_ids.append(tile_id)
-            minx_list.append(bounds.left)
-            maxx_list.append(bounds.right)
-            miny_list.append(bounds.bottom)
-            maxy_list.append(bounds.top)
-
-        if not image_paths:
-            return None
-
-        return {
-            "image_paths": image_paths,
-            "mask_path": mask_path,
-            "start_timestamps": start_ts,
-            "end_timestamps": end_ts,
-            "sentinel_tile_ids": tile_ids,
-            "bboxes": {
-                "minx": minx_list,
-                "maxx": maxx_list,
-                "miny": miny_list,
-                "maxy": maxy_list
+            yield self.generate_index(), {
+                "sample_id": sample_id,
+                "image": image_path,
+                "mask": mask_lookup[sample_id],
             }
-        }
-
-    @classmethod
-    def generate_index(cls, dataset_dir, output_path="index.jsonl"):
-        """
-        Scans the dataset directory and writes a streaming-friendly index.jsonl file.
-
-        Each line is a complete sample in JSON format.
-        """
-        images_dir = os.path.join(dataset_dir, "images")
-        masks_dir = os.path.join(dataset_dir, "masks")
-        sample_ids = sorted(os.listdir(images_dir))
-
-        with open(output_path, "w") as f:
-            for sample_id in tqdm(sample_ids, desc="Generating index", unit="sample"):
-                sample = cls._parse_sample(sample_id, images_dir, masks_dir)
-                if sample:
-                    sample["start_timestamps"] = [ts.isoformat() for ts in sample["start_timestamps"]]
-                    sample["end_timestamps"] = [ts.isoformat() for ts in sample["end_timestamps"]]
-                    sample["sample_id"] = sample_id
-                    f.write(json.dumps(sample) + "\n")
-
-        print(f"✅ Index written to {output_path}")