preprocess.py

from collections import defaultdict

import datasets
from datasets import load_dataset
import numpy as np
from scipy import stats

METADATA_FUNC = {
    "abs": [
        "mean_vmag",
        "phot_g_mean_mag",
        "phot_bp_mean_mag",
        "phot_rp_mean_mag",
        "j_mag",
        "h_mag",
        "k_mag",
        "w1_mag",
        "w2_mag",
        "w3_mag",
        "w4_mag",
    ],
    "cos": ["l"],
    "sin": ["b"],
    "log": ["period"]
}


def preprocess_spectra(example):
    """
    Preprocess spectral data. Steps:
    - Interpolate flux and flux error to a fixed wavelength grid (3850 to 9000 Å).
    - Normalize flux using mean and median absolute deviation (MAD).
    - Append MAD as an auxiliary feature.
    """
    spectra = example['spectra']
    wavelengths = spectra[:, 0]
    flux = spectra[:, 1]
    flux_err = spectra[:, 2]

    # Interpolate flux and flux error onto a fixed grid
    new_wavelengths = np.arange(3850, 9000, 2)
    flux = np.interp(new_wavelengths, wavelengths, flux)
    flux_err = np.interp(new_wavelengths, wavelengths, flux_err)

    # Normalize flux and flux error
    mean = np.mean(flux)
    mad = stats.median_abs_deviation(flux[flux != 0])

    flux = (flux - mean) / mad
    flux_err = flux_err / mad
    aux_values = np.full_like(flux, np.log10(mad))  # Store MAD as an auxiliary feature

    # Stack processed data into a single array
    spectra = np.vstack([flux, flux_err, aux_values])
    example['spectra'] = spectra

    return example


def preprocess_lc(example):
    """
    Preprocess photometry (light curve) data. Steps:
    - Remove duplicate time entries.
    - Sort by Heliocentric Julian Date (HJD).
    - Normalize flux and flux error using mean and median absolute deviation (MAD).
    - Scale time values between 0 and 1.
    - Append auxiliary features (log MAD and time span delta_t).
    """
    X = example['photometry']
    aux_values = np.stack(list(example['metadata']['photo_cols'].values()))

    # Remove duplicate entries
    X = np.unique(X, axis=0)

    # Sort based on HJD
    sorted_indices = np.argsort(X[:, 0])
    X = X[sorted_indices]

    # Normalize flux and flux error
    mean = X[:, 1].mean()
    mad = stats.median_abs_deviation(X[:, 1])
    X[:, 1] = (X[:, 1] - mean) / mad
    X[:, 2] = X[:, 2] / mad

    # Compute delta_t (time span of the light curve in years)
    delta_t = (X[:, 0].max() - X[:, 0].min()) / 365

    # Scale time from 0 to 1
    X[:, 0] = (X[:, 0] - X[:, 0].min()) / (X[:, 0].max() - X[:, 0].min())

    # Add MAD and delta_t to auxiliary metadata features
    aux_values = np.concatenate((aux_values, [np.log10(mad), delta_t]))

    # Add auxiliary features to the sequence
    aux_values = np.tile(aux_values, (X.shape[0], 1))
    X = np.concatenate((X, aux_values), axis=-1)

    example['photometry'] = X
    return example


def transform_metadata(example):
    """
    Transforms the metadata of an example based on METADATA_FUNC.
    """
    metadata = example["metadata"]

    # Process 'abs' transformation on meta_cols:
    # Note: This transformation uses 'parallax' from meta_cols.
    for col in METADATA_FUNC["abs"]:
        if col in metadata["meta_cols"]:
            # Use np.where to avoid issues when parallax is non-positive.
            metadata["meta_cols"][col] = (
                metadata["meta_cols"][col]
                - 10
                + 5 * np.log10(np.where(metadata["meta_cols"]["parallax"] <= 0, 1, metadata["meta_cols"]["parallax"]))
            )

    # Process 'cos' transformation on meta_cols:
    for col in METADATA_FUNC["cos"]:
        if col in metadata["meta_cols"]:
            metadata["meta_cols"][col] = np.cos(np.radians(metadata["meta_cols"][col]))

    # Process 'sin' transformation on meta_cols:
    for col in METADATA_FUNC["sin"]:
        if col in metadata["meta_cols"]:
            metadata["meta_cols"][col] = np.sin(np.radians(metadata["meta_cols"][col]))

    # Process 'log' transformation on photo_cols:
    for col in METADATA_FUNC["log"]:
        if col in metadata["photo_cols"]:
            metadata["photo_cols"][col] = np.log10(metadata["photo_cols"][col])

    # Update the example with the transformed metadata.
    example["metadata"] = metadata
    return example


def compute_metadata_stats(ds):
    """
    Compute the mean and standard deviation for each column in meta_cols and photo_cols.
    """
    meta_vals = defaultdict(list)
    photo_vals = defaultdict(list)

    # Accumulate values for each column
    for example in ds:
        meta = example["metadata"]["meta_cols"]
        photo = example["metadata"]["photo_cols"]
        for col, value in meta.items():
            meta_vals[col].append(value)
        for col, value in photo.items():
            photo_vals[col].append(value)

    # Compute mean and standard deviation for each column
    stats = {"meta_cols": {}, "photo_cols": {}}
    for col, values in meta_vals.items():
        arr = np.stack(values)
        stats["meta_cols"][col] = {"mean": arr.mean(), "std": arr.std()}
    for col, values in photo_vals.items():
        arr = np.stack(values)
        stats["photo_cols"][col] = {"mean": arr.mean(), "std": arr.std()}

    return stats


def normalize_metadata(example, info):
    """
    Normalize metadata values using z-score normalization:
    (value - mean) / std.

    The 'stats' parameter should be a dictionary with computed means and stds for both meta_cols and photo_cols.
    """
    metadata = example["metadata"]

    # Normalize meta_cols
    for col, value in metadata["meta_cols"].items():
        mean = info["meta_cols"][col]["mean"]
        std = info["meta_cols"][col]["std"]
        metadata["meta_cols"][col] = (metadata["meta_cols"][col] - mean) / std

    # Normalize photo_cols
    for col, value in metadata["photo_cols"].items():
        mean = info["photo_cols"][col]["mean"]
        std = info["photo_cols"][col]["std"]
        metadata["photo_cols"][col] = (metadata["photo_cols"][col] - mean) / std

    example["metadata"] = metadata
    return example


def preprocess_metadata(example):
    """
    Extract the values from 'meta_cols' and stack them into a numpy array.
    """
    example["metadata"] = np.stack(list(example["metadata"]["meta_cols"].values()))
    return example


def main():
    """
    Main function for processing and uploading datasets.

    - Loads each dataset based on subset and random seed.
    - Applies preprocessing for spectra, photometry, and metadata.
    - Casts columns to appropriate feature types.
    - Pushes the processed dataset to Hugging Face Hub.
    """
    for sub in ["sub10", "sub25", "sub50", "full"]:
        for seed in [42, 66, 0, 12, 123]:
            name = f"{sub}_{seed}"
            print(f"Processing: {name}")

            # Load dataset from Hugging Face Hub
            ds = load_dataset('AstroMLCore/AstroM3Dataset', name=name, trust_remote_code=True, num_proc=16)
            ds = ds.with_format('numpy')

            # Transform and normalize metadata
            ds = ds.map(transform_metadata, num_proc=16)
            info = compute_metadata_stats(ds['train'])
            ds = ds.map(lambda example: normalize_metadata(example, info))

            # Transform spectra
            ds = ds.map(preprocess_spectra, num_proc=16)
            ds = ds.cast_column('spectra', datasets.Array2D(shape=(3, 2575), dtype='float32'))

            # Transform photometry
            ds = ds.map(preprocess_lc, num_proc=16)
            ds = ds.cast_column('photometry', datasets.Array2D(shape=(None, 9), dtype='float32'))

            # Stack metadata into one numpy array
            ds = ds.map(preprocess_metadata, num_proc=16)
            ds = ds.cast_column('metadata', datasets.Sequence(feature=datasets.Value('float32'), length=34))

            # Change label type
            ds = ds.cast_column('label', datasets.ClassLabel(
                names=['DSCT', 'EA', 'EB', 'EW', 'HADS', 'M', 'ROT', 'RRAB', 'RRC', 'SR']))

            # Upload processed dataset to Hugging Face Hub
            ds.push_to_hub('AstroMLCore/AstroM3Processed', config_name=name)


if __name__ == '__main__':
    main()