Upload folder using huggingface_hub

ZoomLDM-demo-dataset.py

@@ -1,7 +1,8 @@
 import datasets
-import os
 import numpy as np
-from PIL import Image
+from pathlib import Path
+import torch
+import torch.nn.functional as F
 
 _DATASET_VERSION = datasets.Version("1.0.0")
 
@@ -9,50 +10,62 @@ _N_EMBED = {
     "20x": 1,
     "10x": 4,
     "5x": 16,
-    "2_5x": 64,
-    "1_25x": 256,
+    "2.5x": 64,
+    "1.25x": 256,
 }
 
 _MAG_DICT = {
-    "20x": 0,
-    "10x": 1,
-    "5x": 2,
-    "2_5x": 3,
-    "1_25x": 4,
+    "20x": "20x",
+    "10x": "10x",
+    "5x": "5x",
+    "2.5x": "2.5x",
+    "1.25x": "1.25x",
 }
 
 _FIXED_SSL_FEATURE_DIM_1 = 1024
 
 def get_ssl_feat_shape(mag_level):
     first_dim = _N_EMBED[mag_level]
-    return (first_dim, _FIXED_SSL_FEATURE_DIM_1)
+    h = int(np.sqrt(first_dim))
+    return (_FIXED_SSL_FEATURE_DIM_1, h, h)
 
 def preprocess_features(feat_array):
-    feat_array = feat_array.astype(np.float32)
+
+    if len(feat_array.shape) == 1:
+        feat_array = feat_array[:, None]
+
     mean = feat_array.mean(axis=0, keepdims=True)
     std = feat_array.std(axis=0, keepdims=True)
-    processed_feat = (feat_array - mean) / (std + 1e-8)
-    return processed_feat
+    feat_array = (feat_array - mean) / (std + 1e-8)
+
+    h = np.sqrt(feat_array.shape[1]).astype(int)
+    feat_array = torch.tensor(feat_array.reshape((-1, h, h)))
+
+    if h > 8:
+        shape = (8, 8)
+        feat_array = F.adaptive_avg_pool2d(feat_array, shape)
+
+    return feat_array
 
 class MagnificationConfig(datasets.BuilderConfig):
-    def __init__(self, mag_level=None, ssl_feat_shape=None, **kwargs):
+    def __init__(self, mag_level=None, ssl_feat_shape=None, data_dir=None, **kwargs):
         super(MagnificationConfig, self).__init__(**kwargs)
         self.mag_level = mag_level
         self.ssl_feat_shape = ssl_feat_shape
+        self.data_dir = data_dir
 
 class TCGADataset(datasets.GeneratorBasedBuilder):
     VERSION = _DATASET_VERSION
-    MAGNIFICATIONS = ["20x", "10x", "5x", "2_5x", "1_25x"]
+    MAGNIFICATIONS = ["20x", "10x", "5x", "2.5x", "1.25x"]
     BUILDER_CONFIGS = []
-    for mag_level in MAGNIFICATIONS:
-        feature_shape = get_ssl_feat_shape(mag_level)
-        
+    for mag_level_str in MAGNIFICATIONS:
+        feature_shape = get_ssl_feat_shape(mag_level_str)
         builder_config_instance = MagnificationConfig(
-            name=mag_level,
+            name=mag_level_str,
             version=_DATASET_VERSION,
-            description=f"Dataset at {mag_level} mag. SSL feature shape: {feature_shape}",
-            data_dir=mag_level,
-            mag_level=mag_level,
+            description=f"Dataset at {mag_level_str} mag. SSL feature shape: {feature_shape}",
+            data_dir=mag_level_str,
+            mag_level=mag_level_str,
             ssl_feat_shape=feature_shape
         )
         BUILDER_CONFIGS.append(builder_config_instance)
@@ -60,64 +73,64 @@ class TCGADataset(datasets.GeneratorBasedBuilder):
     DEFAULT_CONFIG_NAME = "20x"
 
     def _info(self):
-
-        _CITATION = """\
-            @inproceedings{yellapragada2024zoomldm,
-            title={Learned representation-guided diffusion models for large-image generation},
-            author={Yellapragada, Srikar and Graikos, Alexandros and Triaridis, Kostas and Prasanna, Prateek and Gupta, Rajarsi R and Saltz, Joel and Samaras, Dimitris},
-            booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-            year={2025}
-            }
-        """
-
         return datasets.DatasetInfo(
             description=f"Dataset with images and SSL features. Configuration: {self.config.name}",
             features=datasets.Features(
                 {
                     "image": datasets.Image(),
-                    "ssl_feat": datasets.Array2D(shape=self.config.ssl_feat_shape, dtype="float16"),
+                    "ssl_feat": datasets.Array3D(shape=self.config.ssl_feat_shape, dtype="float32"),
                     "filename_img": datasets.Value("string"),
                     "filename_feat": datasets.Value("string"),
                     "mag": datasets.Value("string"),
                 }
             ),
             homepage="https://github.com/cvlab-stonybrook/ZoomLDM",
-            citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
+        # self.base_path is set by the datasets library to the directory
+        # of the original script when loading a local script file.
+        # e.g., if script is at './zoomldm_data/ZoomLDM-demo-dataset.py',
+        # self.base_path will be the absolute path to './zoomldm_data/'
+        if not self.base_path:
+            # This should not happen when loading a local script file directly
+            raise ValueError("Dataset Builder's base_path is not set. Cannot locate local data.")
+
+        original_script_dir = Path(self.base_path)
         mag_folder_name = self.config.data_dir
-        mag_data_path = os.path.join("data", mag_folder_name)
-
+        
+        # Construct the absolute path to the 'data/magnification_folder_name'
+        # relative to the original script's directory.
+        mag_data_abs_path = original_script_dir / "data" / mag_folder_name
+        
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "mag_folder_path": mag_data_path,
+                    "mag_folder_abs_path": mag_data_abs_path, # Pass the absolute Path object
                     "mag_level": self.config.mag_level,
                 },
             ),
         ]
 
-    def _generate_examples(self, mag_folder_path, mag_level):
+    def _generate_examples(self, mag_folder_abs_path: Path, mag_level: str):
         idx = 0
         for i in range(16):
             img_filename = f"{i}.jpg"
             feat_filename = f"{i}_ssl_feat.npy"
 
-            img_path = os.path.join(mag_folder_path, img_filename)
-            feat_path = os.path.join(mag_folder_path, feat_filename)
+            img_path = mag_folder_abs_path / img_filename
+            feat_path = mag_folder_abs_path / feat_filename
 
-            if not (os.path.exists(img_path) and os.path.exists(feat_path)):
-                continue
 
             ssl_feat_data = np.load(feat_path)
-
             processed_feature = preprocess_features(ssl_feat_data)
 
             yield idx, {
-                "image": img_path,
-                "ssl_feat": processed_feature.astype(np.float16),
+                "image": str(img_path), # datasets.Image() handles path strings
+                "ssl_feat": processed_feature,
+                "filename_img": img_filename,
+                "filename_feat": feat_filename,
                 "mag": _MAG_DICT[mag_level],
             }
             idx += 1