README.md

---
license: mit
language:
- en
pretty_name: STAR
size_categories:
- 100M<n<1B
task_categories:
- image-to-image
tags:
- astronomy
- super-resolution
- computer-vision
- hubble-space-telescope
configs:
- config_name: default
  data_files:
  - split: train
    path: sampled_data/x2/train_metadata.jsonl
  - split: validation
    path: sampled_data/x2/validation_metadata.jsonl
---

# STAR Dataset (Super-Resolution for Astronomical Star Fields)

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.

## 🌟 Key Features

- **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

## 📊 Dataset Structure

```
KUOCHENG/STAR/
├── sampled_data/x2/              #  ⚠️ SAMPLE ONLY - For testing/exploration(600 samples). You can get started quickly with the data here.
│   ├── 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)
```
⚠️ Important Note: The sampled_data/ directory contains only a small subset (600 pairs) for quick testing and understanding the data structure. For actual training and research, please use the full datasets in data/ directory.
## 🚀 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

⚠️NOTE: Complete training and testing code/framework, please see [github](https://github.com/GuoCheng12/STAR).

```python
import numpy as np
from datasets import load_dataset
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
### 🔭 Astronomical Image Visualization
Astronomical images have extreme dynamic ranges with both very bright stars and faint background features. Direct visualization often shows only the brightest sources. We need special normalization techniques for proper visualization.
```python
import matplotlib.pyplot as plt
import numpy as np
from astropy.visualization import ZScaleInterval, ImageNormalize

# If astropy is not installed: pip install astropy

def z_scale_normalize(image, contrast=0.25):
    """
    Apply Z-scale normalization for astronomical images.
    This technique enhances faint features while preventing bright stars from saturating.
    
    Args:
        image: Input astronomical image
        contrast: Contrast parameter (default 0.25, lower = more contrast)
    
    Returns:
        Normalized image suitable for visualization
    """
    # Remove NaN and Inf values
    image_clean = np.nan_to_num(image, nan=0.0, posinf=0.0, neginf=0.0)
    
    interval = ZScaleInterval(contrast=contrast)
    vmin, vmax = interval.get_limits(image_clean)
    norm = ImageNormalize(vmin=vmin, vmax=vmax)
    return norm(image_clean)

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_image_vis = z_scale_normalize(hr_data)
    lr_image_vis = z_scale_normalize(lr_data)

    # 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 the paper for details) 


## 📝 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}
}

```

## 📄 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)