initial commit

.gitattributes

@@ -49,6 +49,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.gif filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.tiff filter=lfs diff=lfs merge=lfs -text
+*.fits filter=lfs diff=lfs merge=lfs -text
+*.fit filter=lfs diff=lfs merge=lfs -text
 # Image files - compressed
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text

GBI-16-2D-Legacy.py

@@ -0,0 +1,189 @@
+import os
+import random
+from glob import glob
+import json
+from huggingface_hub import hf_hub_download
+
+
+from astropy.io import fits
+import datasets
+from datasets import DownloadManager
+from fsspec.core import url_to_fs
+
+_DESCRIPTION = (
+"GBI-16-2D-Legacy is a Huggingface `dataset` wrapper around a compression "
+"dataset assembled by Maireles-González et al. (Publications of the "
+"Astronomical Society of the Pacific, 135:094502, 2023 September; doi: "
+"[https://doi.org/10.1088/1538-3873/acf6e0](https://doi.org/10.1088/1538-3873/"
+"acf6e0)). It contains 226 FITS images from 5 different ground-based "
+"telescope/cameras with a varying amount of entropy per image."
+)
+
+_HOMEPAGE = "https://google.github.io/AstroCompress"
+
+_LICENSE = "CC BY 4.0"
+
+_URL = "https://huggingface.co/datasets/AstroCompress/GBI-16-2D-Legacy/resolve/main/"
+
+_URLS = {
+    "tiny": {
+        "train": "./splits/tiny_train.jsonl",
+        "test": "./splits/tiny_test.jsonl",
+    },
+    "full": {
+        "train": "./splits/full_train.jsonl",
+        "test": "./splits/full_test.jsonl",
+    }
+}
+
+_REPO_ID = "AstroCompress/GBI-16-2D-Legacy"
+
+class GBI_16_2D_Legacy(datasets.GeneratorBasedBuilder):
+    """GBI-16-2D-Legacy Dataset"""
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name="tiny",
+            version=VERSION,
+            description="A small subset of the data, to test downsteam workflows.",
+        ),
+        datasets.BuilderConfig(
+            name="full",
+            version=VERSION,
+            description="The full dataset",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "tiny"
+
+    def __init__(self, **kwargs):
+        super().__init__(version=self.VERSION, **kwargs)
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    # Images are variable size across the dataset
+                    # so use the Image type here, returning as
+                    # numpy uint16
+                    "image": datasets.Image(decode=True, mode="I;16"),
+                    "telescope": datasets.Value("string"),
+                    "image_id": datasets.Value("string"),
+                }
+            ),
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation="TBD",
+        )
+
+    def _split_generators(self, dl_manager: DownloadManager):
+
+        ret = []
+        base_path = dl_manager._base_path
+        locally_run = not base_path.startswith(datasets.config.HF_ENDPOINT) 
+        _, path = url_to_fs(base_path)
+
+        for split in ["train", "test"]:
+            if locally_run:
+                split_file_location = os.path.normpath(os.path.join(path, _URLS[self.config.name][split]))
+                split_file = dl_manager.download_and_extract(split_file_location)
+            else:
+                split_file = hf_hub_download(repo_id=_REPO_ID, filename=_URLS[self.config.name][split], repo_type="dataset")
+            with open(split_file, encoding="utf-8") as f:
+                data_filenames = []
+                data_metadata = []
+                for line in f:
+                    item = json.loads(line)
+                    data_filenames.append(item["image"])
+                    data_metadata.append({"telescope": item["telescope"],
+                                          "image_id": item["image_id"]})
+                if locally_run:
+                    data_urls = [os.path.normpath(os.path.join(path,data_filename)) for data_filename in data_filenames]
+                    data_files = [dl_manager.download(data_url) for data_url in data_urls]
+                else:
+                    data_urls = data_filenames
+                    data_files = [hf_hub_download(repo_id=_REPO_ID, filename=data_url, repo_type="dataset") for data_url in data_urls]
+            ret.append(
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN if split == "train" else datasets.Split.TEST,
+                    gen_kwargs={"filepaths": data_files,
+                                "split_file": split_file,
+                                "split": split, 
+                                "data_metadata": data_metadata},
+                ),
+            )
+        return ret
+
+    def _generate_examples(self, filepaths, split_file, split, data_metadata):
+        """Generate GBI-16-2D-Legacy examples"""
+
+        for idx, (filepath, item) in enumerate(zip(filepaths, data_metadata)):
+            task_instance_key = f"{self.config.name}-{split}-{idx}"
+            with fits.open(filepath, memmap=False) as hdul:
+                # this data is natively formatted like (1, 4200, 2154)
+                # just use the 2D image
+                image_data = hdul[0].data[0,:,:].tolist()
+                yield task_instance_key, {**{"image": image_data}, **item}
+
+def make_split_jsonl_files(config_type="tiny", data_dir="./data", 
+                           telescope_subdirectories=["INT", "JKT","LCO", "TJO", "WHT"],
+                          outdir="./splits", seed=42):
+    """
+    Create jsonl files for the GBI-16-2D-Legacy dataset.
+
+    config_type: str, default="tiny"
+        The type of split to create. Options are "tiny" and "full".
+    data_dir: str, default="./data"
+        The directory where the FITS files are located.
+    telescope_subdirectories: list, default=["INT", "JKT","LCO", "TJO", "WHT"]
+        The subdirectories of the data_dir that contain the FITS files for each telescope.
+    outdir: str, default="./splits"
+        The directory where the jsonl files will be created.
+    seed: int, default=42
+        The seed for the random split.
+    """
+    random.seed(seed)
+    os.makedirs(outdir, exist_ok=True)
+
+    fits_files = []
+    for subdir in telescope_subdirectories:
+        fits_files.extend(glob(os.path.join(data_dir, subdir, "*.fits")))
+
+    random.shuffle(fits_files)
+
+    if config_type == "tiny":
+        train_files = []
+        test_files = []
+        for subdir in telescope_subdirectories:
+            subdir_files = [f for f in fits_files if subdir in f]
+            train_files.extend(subdir_files[:2])
+            test_files.extend(subdir_files[2:3])
+    elif config_type == "full":
+        train_files = []
+        test_files = []
+        for subdir in telescope_subdirectories:
+            subdir_files = [f for f in fits_files if subdir in f]
+            split_idx = int(0.8 * len(subdir_files))
+            train_files.extend(subdir_files[:split_idx])
+            test_files.extend(subdir_files[split_idx:])
+    else:
+        raise ValueError("Unsupported config_type. Use 'tiny' or 'full'.")
+
+    def create_jsonl(files, split_name):
+        output_file = os.path.join(outdir, f"{config_type}_{split_name}.jsonl")
+        with open(output_file, "w") as out_f:
+            for file in files:
+                print(file, flush=True, end="...")
+                with fits.open(file, memmap=False) as hdul:
+                    image_id = os.path.basename(file).split(".fits")[0]
+                
+                    telescope = hdul[0].header.get('TELESCOP', 'UNKNOWN')
+                    item = {"image_id": image_id, "image": file, "telescope": telescope}
+                    out_f.write(json.dumps(item) + "\n")
+
+    create_jsonl(train_files, "train")
+    create_jsonl(test_files, "test")

README.md

@@ -1,3 +1,90 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+pretty_name: Ground-based 2d images assembled in Maireles-González et al.
+tags:
+- astronomy
+- compression
+- images
+dataset_info:
+  config_name: tiny
+  features:
+  - name: image
+    dtype:
+      image:
+        mode: I;16
+  - name: telescope
+    dtype: string
+  - name: image_id
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 307620692
+    num_examples: 10
+  - name: test
+    num_bytes: 168984694
+    num_examples: 5
+  download_size: 238361934
+  dataset_size: 476605386
+---
+
+# GBI-16-2D-Legacy Dataset
+
+GBI-16-2D-Legacy is a Huggingface `dataset` wrapper around a compression dataset assembled by Maireles-González et al. (Publications of the Astronomical Society of the Pacific, 135:094502, 2023 September; doi: [https://doi.org/10.1088/1538-3873/acf6e0](https://doi.org/10.1088/1538-3873/acf6e0)). It contains 226 FITS images from 5 different ground-based telescope/cameras with a varying amount of entropy per image.
+
+# Usage
+
+You first need to install the `datasets` and `astropy` packages:
+
+```bash
+pip install datasets astropy
+```
+
+There are two datasets: `tiny` and `full`, each with `train` and `test` splits. The `tiny` dataset has 2 4D images in the `train` and 1 in the `test`. The `full` dataset contains all the images in the `data/` directory.
+
+## Use from Huggingface Directly
+
+To directly use from this data from Huggingface, you'll want to log in on the command line before starting python:
+
+```bash
+huggingface-cli login
+```
+
+or
+
+```
+import huggingface_hub
+huggingface_hub.login(token=token)
+```
+
+Then in your python script:
+
+```python
+from datasets import load_dataset
+dataset = load_dataset("AstroCompress/GBI-16-2D-Legacy", "tiny")
+ds = dataset.with_format("np")
+```
+
+## Local Use
+
+Alternatively, you can clone this repo and use directly without connecting to hf:
+
+```bash
+git clone https://huggingface.co/datasets/AstroCompress/GBI-16-2D-Legacy
+```
+
+Then `cd SBI-16-3D` and start python like:
+
+```python
+from datasets import load_dataset
+dataset = load_dataset("./GBI-16-2D-Legacy", "tiny", data_dir="./data/")
+ds = dataset.with_format("np")
+```
+
+Now you should be able to use the `ds` variable like:
+
+```python
+ds["test"][0]["image"].shape # -> (9, 2048, 2048)
+```
+
+Note of course that it will take a long time to download and convert the images in the local cache for the `full` dataset. Afterward, the usage should be quick as the files are memory-mapped from disk.
+