Create terramesh.py

terramesh.py

@@ -0,0 +1,317 @@
+# Copyright 2025 IBM Corp.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This file includes code adapted from the original work by EPFL and Apple Inc.,
+# licensed under the Apache License, Version 2.0.
+# Source: https://github.com/apple/ml-4m/
+
+import os
+import io
+import re
+import zarr
+import fsspec
+import itertools
+import braceexpand
+import numpy as np
+import webdataset as wds
+from collections.abc import Callable, Iterable
+from sympy.printing.pytorch import torch
+from torch.utils.data._utils.collate import default_collate
+from webdataset.handlers import warn_and_continue
+
+
+# Definition of all shard files in TerraMesh
+split_files = {
+    "ssl4eos12": {
+        "train": ["ssl4eos12_shard_{000794..000889}.tar"],
+        "val": ["ssl4eos12_shard_000009.tar"],
+    },
+    "majortom": {
+        "train": ["majortom_shard_{000001..000793}.tar"],
+        "val": ["majortom_shard_{000001..000008}.tar"],
+    },
+    "combined": {
+        "train": ["majortom_shard_{000001..000793}.tar", "ssl4eos12_shard_{000794..000889}.tar"],
+        "val": ["majortom_shard_{000001..000008}.tar", "ssl4eos12_shard_000009.tar"],
+    }
+}
+
+
+def build_terramesh_dataset(
+        path: str = "https://huggingface.co/datasets/ibm-esa-geospatial/TerraMesh/resolve/main/",
+        modalities=None,
+        split: str = "val",
+        urls: str | None = None,
+        batch_size: int = 8,
+        *args, **kwargs,
+):
+
+    if len(modalities) == 1:
+        # Build standard WebDataset for single modality
+        dataset = build_wds_dataset(
+            path=path,
+            modality=modalities[0],
+            split=split,
+            urls=urls,
+            batch_size=batch_size,
+            *args, **kwargs
+        )
+        return dataset
+
+    else:
+        # Build custom multi-modal dataset
+        dataset = build_multimodal_dataset(
+            path=path,
+            modalities=modalities,
+            split=split,
+            urls=urls,
+            batch_size=batch_size,
+            *args, **kwargs,
+        )
+        return dataset
+
+
+def zarr_decoder(key, value):
+    if key == "zarr.zip" or key.endswith(".zarr.zip"):
+        mapper = fsspec.filesystem("zip", fo=io.BytesIO(value), block_size=None).get_mapper("")
+        return zarr.open_consolidated(mapper, mode="r")['bands'][...]
+
+
+def identity(sample):
+    """Identity function that does nothing."""
+    return sample
+
+
+def drop_time_dim(value, dim: int = 0):
+    """
+    Remove time dimension from data tensors.
+    """
+    if isinstance(value, np.ndarray) or isinstance(value, torch.Tensor):
+        return value.squeeze(dim)
+
+    elif isinstance(value, dict):
+        for k, v in value.items():
+            if isinstance(v, np.ndarray) or isinstance(v, torch.Tensor):
+                value[k] = v.squeeze(dim)
+        return value
+
+
+def build_wds_dataset(
+        path: str = "https://huggingface.co/datasets/ibm-esa-geospatial/TerraMesh/resolve/main/",
+        modality: str = "S2L2A",
+        split: str = "val",
+        urls: str | None = None,
+        batch_size: int = 8,
+        transform: Callable = None,
+        *args, **kwargs
+):
+    if urls is None:
+        # Select split files
+        if modality == "S1GRD":
+            files = split_files["ssl4eos12"][split]
+        elif modality == "S1GRD":
+            files = split_files["majortom"][split]
+        else:
+            files = split_files["combined"][split]
+
+        # Joins majortom and ssl4eos12 shard files with "::" (except for S-1 modalities)
+        urls = "::".join(
+            [os.path.join(path, split, modality, f) for f in files]
+        )
+
+    kwargs["shardshuffle"] = kwargs.get("shardshuffle", 100)  # Shuffle shard by default
+
+    # Build dataset
+    dataset = (
+        wds.WebDataset(urls, *args, **kwargs)
+        .decode(zarr_decoder)  # Decode byte files
+        .rename(image='zarr.zip')
+        .map_dict(image=drop_time_dim)  # Remove temporal dimension
+    )
+
+    if transform is not None:
+        dataset = dataset.map(transform)
+
+    # Create batches
+    if batch_size is not None:
+        dataset = dataset.batched(batch_size)
+
+    return dataset
+
+
+def combine_datasets(*args):
+    return itertools.chain(*args)
+
+
+def build_multimodal_dataset(
+        path: str = "https://huggingface.co/datasets/ibm-esa-geospatial/TerraMesh/resolve/main/",
+        modalities: str = "S2L2A",
+        split: str = "val",
+        urls: str | None = None,
+        batch_size: int = 8,
+        transform: Callable = None,
+        *args, **kwargs
+):
+    if urls is None:
+        # Filter modalities based availability (S1GRD and S1RTC not present in all subsets)
+        def filter_list(lst, value):
+            lst = lst.copy()
+            # helper function to filter modalities
+            if value in lst:
+                lst.remove(value)
+            return lst
+
+
+        majortom_mod = f"[{','.join(filter_list(modalities, 'S1GRD'))}]"
+        ssl4eos12_mod = f"[{','.join(filter_list(modalities, 'S1RTC'))}]"
+
+        # Joins majortom and ssl4eos12 shard files with "::"
+        urls = (os.path.join(path, split, majortom_mod,  split_files["majortom"][split][0])
+                + "::" + os.path.join(path, split, ssl4eos12_mod, split_files["ssl4eos12"][split][0]))
+
+    dataset = build_datapipeline(urls, transform, batch_size, *args, **kwargs)
+    return dataset
+
+
+def build_datapipeline(urls, transform, batch_size, *args, **kwargs):
+    datapipeline = wds.DataPipeline(
+        # Infinitely sample shards from the shard list with replacement. Each worker is seeded independently.
+        wds.ResampledShards(urls),
+        multi_tarfile_samples,  # Extract individual samples from multi-modal tar files
+        wds.shuffle(100),  # Shuffle with a buffer of given size
+        wds.decode(zarr_decoder),  # Decode from bytes to PIL images, numpy arrays, etc.
+        wds.map(drop_time_dim),  # Remove time dimension from tensors
+        wds.map(remove_extensions),  # Remove "file extensions" from dictionary keys
+        (   # Apply transformation
+            wds.map(transform)
+            if transform is not None
+            else wds.map(identity)
+        ),
+        (   # Batching
+            wds.batched(batch_size, collation_fn=default_collate, partial=False)
+            if batch_size is not None
+            else wds.map(identity)
+        ),
+    )
+    return datapipeline
+
+
+def extract_modality_names(s):
+    """
+    Function from https://github.com/apple/ml-4m/blob/main/fourm/data/unified_datasets.py.
+    """
+    # Regular expression pattern to match anything enclosed in '{' and '}', and comma separated
+    pattern = r"\{([^}]*)\}"
+    match = re.search(pattern, s)
+    return match.group(1).split(",") if match else []
+
+
+def remove_ext_with_gz(s):
+    """
+    Function from https://github.com/apple/ml-4m/blob/main/fourm/data/unified_datasets.py.
+    """
+    if s.endswith(".gz"):
+        s = s.replace(".gz", "")
+    if s.endswith(".zip"):
+        s = s.replace(".zip", "")
+    return os.path.splitext(s)[0]
+
+
+def remove_extensions(sample):
+    """
+    Function from https://github.com/apple/ml-4m/blob/main/fourm/data/unified_datasets.py.
+
+    In webdatasets, we identify the type of a given modality by adding an extension
+    in the form f"{modality_name}.{modality_extension}", e.g. "rgb.jpg" or "caption.json".
+    This function removes them and returns a dictionary of {f"{modality_name}": modality}.
+    """
+    return {remove_ext_with_gz(k): v for k, v in sample.items()}
+
+
+def multi_tarfile_samples(
+    src_iter: Iterable[dict],
+    handler: Callable[[Exception], bool] = warn_and_continue,
+):
+    """
+    This function is adapted from https://github.com/apple/ml-4m/blob/main/fourm/data/unified_datasets.py.
+
+    Webdataset does not support splitting up shards by modality, so we need to do this manually.
+    Usually, we would need to save all modalities in the same tar file, e.g. shard_root_train/{00000..12345}.tar,
+    where each shard contains 1000 samples and each sample contains all modalities.
+    This is not flexible when adding new modalities, so we instead save each modality in a separate tar file,
+    e.g. shard_root_train_rgb/{00000..12345}.tar, shard_root_train_caption/{00000..12345}.tar, etc., where each shard contains
+    again 1000 samples, but each sample contains only one modality. All samples in all shards have to be aligned.
+
+    This function takes an iterator over shard URLs, where we use brace expansion to specify multiple tar files per modality.
+    E.g. shard_root_train_[rgb,caption]/00123.tar will be expanded to shard_root_train_rgb/00123.tar and shard_root_train_caption/00123.tar,
+    and the samples from these two tar files will be combined into a single sample.
+
+    Args:
+        src_iter: Iterator over shards that *already brace expanded the shard numbers*,
+            e.g. {'url': 'shard_root_train_[rgb,caption]/00000.tar'}, {'url': 'shard_root_train_[rgb,caption]/00001.tar'}, ...
+            This function will also work when no square braces for multiple modalities are used, e.g. {'url': 'shard_root_train/00000.tar'}, ...
+            It can be a drop-in replacement for wds.tarfile_samples.
+        handler: Function that handles exceptions. If it returns True, the shard is skipped. If it returns False, the function exits.
+
+    Yields:
+        Dictionary of aligned samples from all modalities.
+    """
+
+    for src in src_iter:
+
+        # Multi tar file URLs use brace expansion with square braces
+        multi_tar_urls = src["url"].translate(str.maketrans("[]", "{}"))
+        modality_names = extract_modality_names(multi_tar_urls)
+        multi_tar_urls = list(braceexpand.braceexpand(multi_tar_urls))
+
+        # Create tar iterators for shards of all modalities
+        tar_iters = [
+            wds.tarfile_samples([{"url": tar_url}]) for tar_url in multi_tar_urls
+        ]
+
+        try:
+            # Loop over these iterators in parallel and combine the tar files from different modalities
+            for multi_tar_files in zip(*tar_iters):
+
+                merged_dict = {}
+                merged_dict["__key__"] = multi_tar_files[0]["__key__"]
+                merged_dict["__url__"] = src["url"]
+
+                for modality_name, modality_dict in zip(
+                    modality_names, multi_tar_files
+                ):
+                    _key = modality_dict.pop("__key__")
+                    _url = modality_dict.pop("__url__")
+
+                    if _key != merged_dict["__key__"]:
+                        raise ValueError(
+                            f"Divergence detected! Trying to merge keys {_key} of {modality_name} and {merged_dict['__key__']} of merged_dict with modalities {merged_dict.keys()}."
+                        )
+
+                    for k, v in modality_dict.items():
+                        if modality_name is None:
+                            merged_dict[k] = v
+                        else:
+                            merged_dict[f"{modality_name}.{k}"] = v
+
+                yield merged_dict
+
+        except Exception as e:
+            print(e)
+            print(f"Exception occurred while processing {src['url']}.")
+            if handler(e):
+                print("Skipping shard...")
+                continue
+            else:
+                break