Update README.md

README.md

@@ -11,6 +11,7 @@ tags:
 - astronomy
 - super-resolution
 - computer-vision
+- hubble-space-telescope
 configs:
 - config_name: default
   data_files:
@@ -20,35 +21,248 @@ configs:
     path: sampled_data/x2/validation_metadata.jsonl
 ---
 
+# STAR Dataset (Super-Resolution for Astronomical Star Fields)
 
-# STAR Dataset
-The **STAR (Super-Resolution for Astronomical Star Fields)** dataset is a large-scale benchmark for developing field-level super-resolution models in astronomy. It contains **54,738 flux-consistent image pairs** derived from Hubble Space Telescope (HST) high-resolution observations and physically faithful low-resolution counterparts. The dataset addresses three key challenges in astronomical super-resolution:
+The **STAR** dataset is a large-scale benchmark for developing field-level super-resolution models in astronomy. It contains **54,738 flux-consistent image pairs** derived from Hubble Space Telescope (HST) high-resolution observations and physically faithful low-resolution counterparts.
 
-- **Flux Inconsistency**: Ensures consistent flux using a flux-preserving data generation pipeline.
-- **Object-Crop Configuration**: Strategically samples patches across diverse celestial regions.
-- **Data Diversity**: Covers dense star clusters, sparse galactic fields, and regions with varying background noise.
+## 🌟 Key Features
 
-The dataset includes x2 and x4 scaling pairs in `.npy` format, suitable for training and evaluating super-resolution models.
+- **Flux Consistency**: Ensures consistent flux using a flux-preserving data generation pipeline
+- **Object-Crop Configuration**: Strategically samples patches across diverse celestial regions
+- **Data Diversity**: Covers dense star clusters, sparse galactic fields, and regions with varying background noise
+- **Multiple Scales**: Supports both 2x and 4x super-resolution tasks
 
-## Structure
-- **Full Data**:
-  - `data/x2/x2.tar.gz` (33GB): Full x2 dataset.
-  - `data/x4/x4.tar.gz` (29GB): Full x4 dataset.
-  - Unzip to access: `train_hr_patch/`, `train_lr_patch/`, `eval_hr_patch/`, `eval_lr_patch/` (.npy files), and `dataload_filename/` (txt with pairs).
+## 📊 Dataset Structure
 
-- **Sample Data** (for testing and Croissant, x2 only):
-  - `sampled_data/x2/`: Sample .npy pairs (500 train pairs, 100 eval pairs).
-    - `train_hr_patch/`, `train_lr_patch/` (500 files each)
-    - `eval_hr_patch/`, `eval_lr_patch/` (100 files each)
-  - Croissant metadata: `sampled_data/x2/croissant.json`
+```
+KUOCHENG/STAR/
+├── sampled_data/x2/              # Sample dataset (600 pairs)
+│   ├── train_hr_patch/           # 500 HR training patches (.npy files)
+│   ├── train_lr_patch/           # 500 LR training patches (.npy files)
+│   ├── eval_hr_patch/            # 100 HR validation patches (.npy files)
+│   ├── eval_lr_patch/            # 100 LR validation patches (.npy files)
+│   ├── train_metadata.jsonl      # Training pairs metadata
+│   └── validation_metadata.jsonl # Validation pairs metadata
+└── data/
+    ├── x2/x2.tar.gz              # Full x2 dataset (33GB)
+    └── x4/x4.tar.gz              # Full x4 dataset (29GB)
+```
 
+## 🚀 Quick Start
+
+### Loading the Dataset
+
+```python
+from datasets import load_dataset
+import numpy as np
+
+# Load metadata
+dataset = load_dataset("KUOCHENG/STAR")
+
+# Access a sample
+sample = dataset['train'][0]
+hr_path = sample['hr_path']  # Path to HR .npy file
+lr_path = sample['lr_path']  # Path to LR .npy file
+
+# Load actual data
+hr_data = np.load(hr_path, allow_pickle=True).item()
+lr_data = np.load(lr_path, allow_pickle=True).item()
+```
+
+### Understanding the Data Format
+
+Each `.npy` file contains a dictionary with the following structure:
+
+#### High-Resolution (HR) Data
+- **Shape**: `(256, 256)` for all HR patches
+- **Access Keys**:
+  ```python
+  hr_data['image']     # The actual grayscale astronomical image
+  hr_data['mask']      # Binary mask (True = valid/accessible pixels)
+  hr_data['attn_map']  # Attention map from star finder (detected astronomical sources)
+  hr_data['coord']     # Coordinate information (if available)
+  ```
+
+#### Low-Resolution (LR) Data
+- **Shape**: Depends on the super-resolution scale
+  - For x2: `(128, 128)`
+  - For x4: `(64, 64)`
+- **Access Keys**: Same as HR data
+  ```python
+  lr_data['image']     # Downsampled grayscale image
+  lr_data['mask']      # Downsampled mask
+  lr_data['attn_map']  # Downsampled attention map
+  lr_data['coord']     # Coordinate information
+  ```
+
+### Data Fields Explanation
+
+| Field | Description | Type | Usage |
+|-------|-------------|------|-------|
+| `image` | Raw astronomical observation data | `np.ndarray` (float32) | Main input for super-resolution |
+| `mask` | Valid pixel indicator | `np.ndarray` (bool) | Identifies accessible regions (True = valid) |
+| `attn_map` | Star finder output | `np.ndarray` (float32) | Highlights detected astronomical sources (stars, galaxies) |
+| `coord` | Spatial coordinates | `np.ndarray` | Position information for patch alignment |
+
+## 💻 Usage Examples
+
+### Basic Training Loop
 
-## Custom Loading with Split
-To load with split="train":
 ```python
+import numpy as np
 from datasets import load_dataset
-data_files = {
-    "train": ["sampled/x2/train_hr_patch/*.npy", "sampled/x2/train_lr_patch/*.npy"],
-    "validation": ["sampled/x2/eval_hr_patch/*.npy", "sampled/x2/eval_lr_patch/*.npy"]
+import torch
+from torch.utils.data import DataLoader
+
+# Load dataset
+dataset = load_dataset("KUOCHENG/STAR")
+
+class STARDataset(torch.utils.data.Dataset):
+    def __init__(self, hf_dataset):
+        self.dataset = hf_dataset
+    
+    def __len__(self):
+        return len(self.dataset)
+    
+    def __getitem__(self, idx):
+        sample = self.dataset[idx]
+        
+        # Load .npy files
+        hr_data = np.load(sample['hr_path'], allow_pickle=True).item()
+        lr_data = np.load(sample['lr_path'], allow_pickle=True).item()
+        
+        # Extract images
+        hr_image = hr_data['image'].astype(np.float32)
+        lr_image = lr_data['image'].astype(np.float32)
+        
+        # Extract masks for loss computation
+        hr_mask = hr_data['mask'].astype(np.float32)
+        lr_mask = lr_data['mask'].astype(np.float32)
+        
+        # Convert to tensors
+        return {
+            'lr_image': torch.from_numpy(lr_image).unsqueeze(0),  # Add channel dim
+            'hr_image': torch.from_numpy(hr_image).unsqueeze(0),
+            'hr_mask': torch.from_numpy(hr_mask).unsqueeze(0),
+            'lr_mask': torch.from_numpy(lr_mask).unsqueeze(0),
+        }
+
+# Create PyTorch dataset and dataloader
+train_dataset = STARDataset(dataset['train'])
+train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+
+# Training loop example
+for batch in train_loader:
+    lr_images = batch['lr_image']  # [B, 1, 128, 128] for x2
+    hr_images = batch['hr_image']  # [B, 1, 256, 256]
+    masks = batch['hr_mask']       # [B, 1, 256, 256]
+    
+    # Your training code here
+    # pred = model(lr_images)
+    # loss = criterion(pred * masks, hr_images * masks)  # Apply mask to focus on valid regions
+```
+
+### Visualization
+
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+
+def visualize_sample(hr_path, lr_path):
+    # Load data
+    hr_data = np.load(hr_path, allow_pickle=True).item()
+    lr_data = np.load(lr_path, allow_pickle=True).item()
+    
+    fig, axes = plt.subplots(2, 3, figsize=(15, 10))
+    
+    # HR visualizations
+    axes[0, 0].imshow(hr_data['image'], cmap='gray')
+    axes[0, 0].set_title('HR Image (256x256)')
+    
+    axes[0, 1].imshow(hr_data['mask'], cmap='binary')
+    axes[0, 1].set_title('HR Mask (Valid Regions)')
+    
+    axes[0, 2].imshow(hr_data['attn_map'], cmap='hot')
+    axes[0, 2].set_title('HR Attention Map (Detected Sources)')
+    
+    # LR visualizations
+    axes[1, 0].imshow(lr_data['image'], cmap='gray')
+    axes[1, 0].set_title(f'LR Image ({lr_data["image"].shape[0]}x{lr_data["image"].shape[1]})')
+    
+    axes[1, 1].imshow(lr_data['mask'], cmap='binary')
+    axes[1, 1].set_title('LR Mask')
+    
+    axes[1, 2].imshow(lr_data['attn_map'], cmap='hot')
+    axes[1, 2].set_title('LR Attention Map')
+    
+    plt.tight_layout()
+    plt.show()
+
+# Visualize a sample
+sample = dataset['train'][0]
+visualize_sample(sample['hr_path'], sample['lr_path'])
+```
+
+## 📁 File Naming Convention
+
+- **HR files**: `*_hr_hr_patch_*.npy`
+- **LR files**: `*_hr_lr_patch_*.npy`
+
+Files are paired by replacing `_hr_hr_patch_` with `_hr_lr_patch_` in the filename.
+
+## 🔄 Full Dataset Access
+
+For the complete dataset (54,738 pairs), download the compressed files:
+
+```python
+# Manual download and extraction
+import tarfile
+
+# Extract x2 dataset
+with tarfile.open('data/x2/x2.tar.gz', 'r:gz') as tar:
+    tar.extractall('data/x2/')
+
+# The extracted structure will be:
+# data/x2/
+#   ├── train_hr_patch/  # ~45,000 HR patches
+#   ├── train_lr_patch/  # ~45,000 LR patches
+#   ├── eval_hr_patch/   # ~9,000 HR patches
+#   ├── eval_lr_patch/   # ~9,000 LR patches
+#   ├── dataload_filename/
+#   │   ├── train_dataloader.txt  # Training pairs list
+#   │   └── eval_dataloader.txt   # Evaluation pairs list
+#   └── psf_hr/, psf_lr/  # Original unpatched data
+```
+
+## 🎯 Model Evaluation Metrics
+
+When evaluating super-resolution models on STAR, consider:
+
+1. **Masked PSNR/SSIM**: Only compute metrics on valid pixels (where mask=True)
+2. **Source Detection F1**: Evaluate if astronomical sources are preserved
+3. **Flux Preservation**: Check if total flux is maintained (important for astronomy, see paper) 
+```
+
+## 📝 Citation
+
+If you use the STAR dataset in your research, please cite:
+
+```bibtex
+@article{wu2025star,
+  title={STAR: A Benchmark for Astronomical Star Fields Super-Resolution},
+  author={Wu, Kuo-Cheng and Zhuang, Guohang and Huang, Jinyang and Zhang, Xiang and Ouyang, Wanli and Lu, Yan},
+  journal={arXiv preprint arXiv:2507.16385},
+  year={2025},
+  url={https://arxiv.org/abs/2507.16385}
 }
-dataset = load_dataset("KUOCHENG/STAR", data_files=data_files, split="train")
+
+```
+
+## 📄 License
+
+This dataset is released under the MIT License.
+
+## 🤝 Contact
+
+For questions or issues, please open an issue on the [dataset repository](https://huggingface.co/datasets/KUOCHENG/STAR/discussions).
+also can see [github](https://github.com/GuoCheng12/STAR)