Upload 2 files

README.md

@@ -11,6 +11,8 @@ configs:
 
 # Machine Learning Tier
 
+This dataset is a collection of synthetic microlensing light curves designed to accurately represent the yields of microlensing events from the lifetime of the Nancy Grace Roman Space Telescope Galactic Bulge Time Domain Survey. It is intended for the training and benchmarking of machine learning models for microlensing event classification, parameter estimation, and anomaly detection.
+
 The machine learning tier data is provided as a set of normalized tables in Parquet format: **RMDC26_ML_Data_obs.parquet**, **RMDC26_ML_Data_meta.parquet**, and **RMDC26_ML_Data_epoch.parquet**.
 
 ## Entity-Relationship Diagram
@@ -50,7 +52,7 @@ Contains the primary time-series data for all events.
 | `saturation_flag` | float64 | Saturation flag: 0 = unsaturated, 1 = saturated. |
 
 ### 2. Metadata Table (`_meta.parquet`)
-Contains the "ground truth" and physical parameters for each event.
+Contains the simulated physical parameters and lensing variables for each event.
 
 | Column Name | Data Type | Description |
 | :--- | :--- | :--- |
@@ -61,15 +63,16 @@ Contains the "ground truth" and physical parameters for each event.
 | `Field` | float64 | Field identifier. |
 | `EventID` | float64 | Event ID. |
 | `final_weight` | float64 | Population weight for the event. |
-| `ObsGroup_0_chi2` | float64 | Delta ($\chi^2$) between the best fitting single lens model and the true model. |
+| `ObsGroup_0_chi2` | float64 | For binary events, the $\Delta\chi^2$ between the best-fitting single-lens (PSPL) model and the true simulated model ($\chi^2_{\text{PSPL\_fit}} - \chi^2_{\text{true}}$). For single-source single-lens events, this instead stores the $\Delta\chi^2$ of the true simulated model vs a flat baseline fit ($\chi^2_{\text{flat}} - \chi^2_{\text{true}}$). |
+| `is_out_of_season` | boolean | Flag indicating whether the event peak ($t_0$) falls in a seasonal gap (when Roman cannot observe the bulge). |
 | `t0lens1` | float64 | Time of closest approach for the primary lens. |
 | `tE_ref` | float64 | Einstein timescale (reference frame). |
 | `tE_helio` | float64 | Einstein timescale (heliocentric frame). |
 | `u0lens1` | float64 | Impact parameter. |
 | `rho` | float64 | Normalized source radius. |
 | `piE` | float64 | Microlens parallax magnitude. |
-| `piEE` | float64 | Parallax-East term. In equitorial co-ordinates. |
-| `piEN` | float64 | Parallax-North term. In equitorial co-ordinates.|
+| `piEE` | float64 | Parallax-East term. In equatorial coordinates. |
+| `piEN` | float64 | Parallax-North term. In equatorial coordinates. |
 | `piEll` | float64 | Parallax-parallel term. |
 | `piErp` | float64 | Parallax-perpendicular term. |
 | `rE` | float64 | Einstein radius. |
@@ -129,7 +132,7 @@ Contains the "ground truth" and physical parameters for each event.
 | `extinction_F213` | float64 | Extinction in F213. |
 
 ### 3. Epochs Table (`_epoch.parquet`)
-Contains unique spatio-temporal definitions for every observation epoch.
+Maps each unique observation time (BJD) and corresponding telescope coordinates (X, Y, Z relative to the Solar System Barycenter) to a unique epoch ID.
 
 | Column Name | Data Type | Description |
 | :--- | :--- | :--- |
@@ -141,14 +144,23 @@ Contains unique spatio-temporal definitions for every observation epoch.
 
 ## Simulation Details & Disclaimer
 
-**Simulation Engine:** All events have been generated using **GULLS**. More information is available at [gulls-microlensing.github.io](https://gulls-microlensing.github.io/).
+**Simulation Engine:** All events have been generated using the **GULLS** simulator. More information is available at [gulls-microlensing.github.io](https://gulls-microlensing.github.io/).
+
+**Stellar Populations:** The input stellar population catalogs used for the source and lens stars were generated using **synthpop** ([github.com/synthpop-galaxy/synthpop](https://github.com/synthpop-galaxy/synthpop)).
 
 **Event Complexity:**
 - There are three simulations included in this dataset:
     - `RMDC26_1S1L_ML`: Single lens and single source events.
     - `RMDC26_1S2L_ML`: One star - one planet lens and single source events.
-    - `RMDC26_2S2L_ML`: One star - one planet lens and binary source events.
-- Note that not all lens and sources are neccesarily involved in the microlensing event. `ObsGroup_0_chi2` > 160 indicates that an anomaly may be present in the light curve. 
+    - `RMDC26_2S2L_ML`: One star - one planet lens and potentially binary source events.
+- Note that not all lenses and sources are necessarily involved in the microlensing event. `ObsGroup_0_chi2` > 160 for events from the binary lens simulations indicates that an anomaly may be present in the light curve. The anomalies may be planetary perturbations and caustic crossings, finite source effects, or parallax effects.
+
+**Representativeness & Weighting:**
+- This data set only includes potentially detectable microlensing events where the chi-squared difference between the best fit flat model and the true model is greater than 60, i.e. $$\chi^2_{\text{flat}} - \chi^2_{\text{true}} > 60$$.
+- The full set of events is **not directly representative** of the raw astrophysical population due to detection significance cuts and GULLS coordinate transformations (e.g. in `croin` caustic-relative coordinates, the host star $t_0$ and $u_0$ are often transformed far outside of normal ranges or observing seasons, even though the planetary anomaly itself is actively observed in-season).
+- To make the dataset more representative of the true underlying Galactic population, you can apply the population weights stored in the **`final_weight`** column directly during training and analysis, or use them to draw a resampled, less biased dataset.
+- The **`is_out_of_season`** flag indicates whether the closest approach time of the primary lens (`t0lens1`) falls in a seasonal gap when the Galactic Bulge is unobservable. While the lightcurves of these events still show signature features of the microlensing event, their peak stellar magnification is not covered by observations. As a result, these events might be difficult for machine learning models to classify correctly, and you may want to filter them out depending on your specific modeling goals.
+
 
 **Dataset Structure:**
 - The dataset is split into **observations**, **metadata**, and **epochs**.
@@ -156,85 +168,31 @@ Contains unique spatio-temporal definitions for every observation epoch.
 
 **Disclaimer:** This dataset is intended for testing and development purposes and should be used with the understanding of the biases inherent in the simulation sampling.
 
+## Sample Light Curves
+
+Here are normalized light curves for 9 sample events from the dataset (3 from each simulation type: 1S1L, 1S2L, 2S2L), colored by filter band. Each filter's flux is divided by its median value (per event) so all bands appear on the same relative scale — the dashed gray line marks the baseline (ratio = 1). The time axis is zoomed to $t_0 \pm 5 \cdot t_E$.
+
+![Sample Light Curves](lightcurves_sample.png)
+
 ## Code Examples
 
 The dataset is hosted on Hugging Face as `RGES-PIT/MachineLearning` with three configs: `observations`, `metadata`, and `epochs`. Below are examples for loading and working with the data.
 
-### Prerequisites (DuckDB method)
+### Prerequisites
+
+To load the metadata and epochs tables directly from Hugging Face, install the `datasets` and `pandas` libraries:
 
 ```bash
-pip install duckdb huggingface_hub
+pip install datasets pandas pyarrow duckdb huggingface_hub
 ```
 
-Set your Hugging Face token (get one at https://huggingface.co/settings/tokens):
+Set your Hugging Face access token:
 
 ```bash
 export HF_TOKEN="hf_your_token_here"
 ```
 
-### 1. Query with DuckDB (SQL — only downloads what you need)
-
-DuckDB has native support for the `hf://` protocol, so you can run full SQL queries directly against your Hugging Face repo without downloading the entire dataset:
-
-```python
-import duckdb
-from huggingface_hub import HfFileSystem
-
-# Register the Hugging Face filesystem
-duckdb.register_filesystem(HfFileSystem())
-
-# Count unique events (not rows — each event has many observations)
-result = duckdb.sql("""
-    SELECT COUNT(DISTINCT event_id) AS n_events
-    FROM 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet'
-""").fetchone()
-print(f"Unique events: {result[0]:,}")
-
-# Aggregate — only downloads the columns you need
-stats = duckdb.sql("""
-    SELECT 
-        COUNT(*) AS n_obs,
-        AVG(flux_uJy) AS mean_flux,
-        AVG(true_flux_uJy) AS mean_true_flux
-    FROM 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet'
-""").fetchone()
-print(f"{stats[0]:,} total observations")
-print(f"  Mean measured flux : {stats[1]:.2f} μJy")
-print(f"  Mean true flux     : {stats[2]:.2f} μJy")
-
-# Join observations with metadata using SQL
-joined = duckdb.sql("""
-    SELECT 
-        o.event_id,
-        e.bjd,
-        o.filt,
-        o.flux_uJy,
-        m.sim_label,
-        m.tE_helio
-    FROM 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet' o
-    JOIN 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_epoch.parquet' e
-      ON o.epoch_id = e.epoch_id
-    JOIN 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_meta.parquet' m
-      ON o.event_id = m.event_id
-    WHERE m.sim_label = 'RMDC26_1S1L_ML'
-      AND o.filt = 'F146'
-    ORDER BY o.event_id, e.bjd
-""").fetchall()
-print(f"{len(joined)} F146 observations for 1S1L events")
-```
-
-**Expected output:**
-```text
-Unique events: 610
-30,187,680 total observations
-  Mean measured flux : 50.74 μJy
-  Mean true flux     : 50.74 μJy
-11,761,464 F146 observations for 1S1L events
-```
-
-> **Tip:** If your dataset is private or gated, make sure `HF_TOKEN` is set — `HfFileSystem` will automatically authenticate.
-
-### 2. Load all three tables as pandas DataFrames
+### 1. Load the metadata and epochs tables
 
 ```python
 from datasets import load_dataset
@@ -245,110 +203,59 @@ assert token, "Set HF_TOKEN environment variable first"
 
 dataset_name = "RGES-PIT/MachineLearning"
 
-obs = load_dataset(dataset_name, "observations", split="train")
-meta = load_dataset(dataset_name, "metadata", split="train")
-epochs = load_dataset(dataset_name, "epochs", split="train")
-
-obs_df  = obs.to_pandas()
-meta_df = meta.to_pandas()
-epochs_df = epochs.to_pandas()
+# Load metadata and epochs tables (which fit easily in RAM)
+meta_df = load_dataset(dataset_name, "metadata", split="train", token=token).to_pandas()
+epochs_df = load_dataset(dataset_name, "epochs", split="train", token=token).to_pandas()
 
-print(f"Observations : {obs_df.shape[0]:,} rows")
 print(f"Metadata     : {meta_df.shape[0]:,} rows")
 print(f"Epochs       : {epochs_df.shape[0]:,} rows")
 ```
 
 **Expected output:**
 ```text
-Observations : 30,187,680 rows
-Metadata     : 610 rows
-Epochs       : 98,973 rows
+Metadata     : 341,740 rows
+Epochs       : 98,974 rows
 ```
 
-### 3. Query with DuckDB and return a pandas DataFrame
+### 2. Reconstruct a single event's lightcurve
 
-You can also fetch results directly as a pandas DataFrame for further analysis:
+Because the observations table is extremely large (~160 GB in total), loading it in full is not recommended for local machines. Instead, we use DuckDB's remote `hf://` protocol to fetch observations for a single event without downloading the entire table:
 
 ```python
 import duckdb
 from huggingface_hub import HfFileSystem
+import os
+
+token = os.environ.get("HF_TOKEN")
+con = duckdb.connect()
+con.register_filesystem(HfFileSystem(token=token))
 
-duckdb.register_filesystem(HfFileSystem())
+obs_p = "hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet"
+meta_p = "hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_meta.parquet"
+epoch_p = "hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_epoch.parquet"
 
-df = duckdb.sql("""
+event_id = 3000
+
+# Reconstruct a single event's lightcurve
+event_obs = con.execute(f"""
     SELECT 
         o.event_id,
+        m.name,
         e.bjd,
         o.filt,
         o.flux_uJy,
         m.tE_helio,
         m.sim_label
-    FROM 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet' o
-    JOIN 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_epoch.parquet' e
-      ON o.epoch_id = e.epoch_id
-    JOIN 'hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_meta.parquet' m
-      ON o.event_id = m.event_id
+    FROM '{obs_p}' o
+    JOIN '{epoch_p}' e ON o.epoch_id = e.epoch_id
+    JOIN '{meta_p}' m ON o.event_id = m.event_id
+    WHERE o.event_id = {event_id}
+    ORDER BY e.bjd
 """).df()
 
-print(f"Loaded {len(df):,} rows into pandas")
-print(df.head())
-```
-
-**Expected output:**
-```text
-Loaded 30,187,680 rows into pandas
- event_id          bjd filt  flux_uJy  tE_helio      sim_label
-     3000 2.461448e+06 F087  0.035214  3.553733 RMDC26_1S1L_ML
-     3000 2.461448e+06 F087 -0.234762  3.553733 RMDC26_1S1L_ML
-     3000 2.461448e+06 F087  0.042257  3.553733 RMDC26_1S1L_ML
-     3000 2.461449e+06 F087 -0.157291  3.553733 RMDC26_1S1L_ML
-     3000 2.461449e+06 F087  0.110338  3.553733 RMDC26_1S1L_ML
-```
-
-### Sample Light Curves
-
-Here are normalized light curves for 9 sample events from the dataset (3 from each simulation type: 1S1L, 1S2L, 2S2L), colored by filter band. Each filter's flux is divided by its median value (per event) so all bands appear on the same relative scale — the dashed gray line marks the baseline (ratio = 1). The time axis is zoomed to t₀ ± 5·t_E.
-
-![Sample Light Curves](lightcurves_sample.png)
-
-### Prerequisites
-
-```bash
-pip install datasets pandas numpy matplotlib
-```
-
-### 4. Reconstruct a single event's lightcurve
-
-```python
-# Pick an event_id from the metadata
-event_id = 42  # replace with actual event_id
-
-# Merge observations with epochs to get BJD times
-event_obs = obs_df[obs_df["event_id"] == event_id].merge(
-    epochs_df[["epoch_id", "bjd"]], on="epoch_id", how="left"
-)
-event_obs = event_obs.sort_values("bjd")
-
-# Merge with metadata for simulation label and physical parameters
-event_meta = meta_df[meta_df["event_id"] == event_id].iloc[0]
-
-print(f"Event {event_id}: {event_meta['name']} ({event_meta['sim_label']})")
-print(f"  {len(event_obs)} observations")
-print(f"  Einstein timescale tE_helio = {event_meta['tE_helio']:.2f} days")
-
-# Plot the lightcurve
-import matplotlib.pyplot as plt
-
-colors = {"F087": "#e69f00", "F146": "#56b4e9", "F213": "#009e73"}
-for filt, grp in event_obs.groupby("filt"):
-    plt.plot(grp["bjd"] - grp["bjd"].min(), grp["flux_uJy"], "o", markersize=3,
-             color=colors[filt], label=filt)
-
-plt.xlabel("Time (days)")
-plt.ylabel("Flux (μJy)")
-plt.legend()
-plt.yscale("log")
-plt.show()
+print(f"Event {event_id}: {event_obs['name'].iloc[0]} ({event_obs['sim_label'].iloc[0]})")
+print(f"  {len(event_obs):,} observations")
+print(f"  Einstein timescale tE_helio = {abs(event_obs['tE_helio'].iloc[0]):.2f} days")
 ```
 
 **Expected output:**
@@ -357,98 +264,65 @@ Event 3000: RMDC26_003000 (RMDC26_1S1L_ML)
   49,488 observations
   Einstein timescale tE_helio = 3.55 days
 ```
-*(In addition to the console printout, this generates a matplotlib plot window displaying a log-scale flux vs. time lightcurve, with data points colored by filter band.)*
 
-### 5. Filter events by simulation type and anomaly presence
+### 3. Filter events by metadata constraints
+
+You can perform filtering on the metadata table first, and then fetch observations for matched events. To run this efficiently over the network without full-table scans, query observations only for the target event IDs:
 
 ```python
-# ObsGroup_0_chi2 is the delta-chi2 between the best single-lens fit and the true model.
-# A value <= 160 indicates a clean, non-anomalous single-lens event (good single-lens fit).
-# A value > 160 indicates a significant anomaly, such as a planetary or binary perturbation.
+from datasets import load_dataset
+import os
+import duckdb
+from huggingface_hub import HfFileSystem
+
+token = os.environ.get("HF_TOKEN")
+meta_df = load_dataset("RGES-PIT/MachineLearning", "metadata", split="train", token=token).to_pandas()
+
+# Select low-significance single-lens events (chi2 <= 160)
 good_events = meta_df[
     (meta_df["sim_label"] == "RMDC26_1S1L_ML") &
     (meta_df["ObsGroup_0_chi2"] <= 160)
 ]
 
-print(f"{len(good_events)} single-lens events with χ² ≤ 160")
-
-# Get all observations for these events
-good_obs = obs_df[obs_df["event_id"].isin(good_events["event_id"])]
-print(f"{len(good_obs)} corresponding observations")
-```
-
-**Expected output:**
-```text
-48 single-lens events with χ² ≤ 160
-2,375,424 corresponding observations
-```
+print(f"{len(good_events)} events matched filters")
 
-### 6. Subsample for faster exploration
+# Query observations count for matched events via DuckDB filter pushdown
+con = duckdb.connect()
+con.register_filesystem(HfFileSystem(token=token))
+obs_p = "hf://datasets/RGES-PIT/MachineLearning/RMDC26_ML_Data_obs.parquet"
 
-```python
-# Load only a subset of observations (useful for quick prototyping)
-obs_subset = load_dataset(dataset_name, "observations", split="train[:100000]").to_pandas()
-print(f"Subsampled to {len(obs_subset):,} observations")
+event_ids_str = ", ".join(map(str, good_events["event_id"].tolist()))
+good_obs_count = con.execute(f"SELECT COUNT(*) FROM '{obs_p}' WHERE event_id IN ({event_ids_str})").fetchone()[0]
+print(f"{good_obs_count:,} corresponding observations")
 ```
 
 **Expected output:**
 ```text
-Subsampled to 100,000 observations
+58307 events matched filters
+2,885,496,816 corresponding observations
 ```
 
-### 7. Access ground-truth parameters for an event
+### 4. Sum final_weight per simulation
+
+To verify the population representation or check the total astrophysical weights of each simulation, you can sum the `final_weight` column grouped by simulation label:
 
 ```python
-# Get all physical parameters for a single event
-event = meta_df[meta_df["event_id"] == 100].iloc[0]
-
-print("Physical parameters:")
-print(f"  tE_helio        : {event['tE_helio']:.3f} days")
-print(f"  u0lens1         : {event['u0lens1']:.3f}")
-print(f"  Lens_Mass       : {event['Lens_Mass']:.3f} M☉")
-print(f"  Lens_Dist       : {event['Lens_Dist']:.1f} kpc")
-val = event["Source_Is_Binary"]
-print(f"  Source_Is_Binary: {0 if pd.isna(val) else int(val)}")
-print(f"  χ²              : {event['ObsGroup_0_chi2']:.1f}")
+# Sum weights and count events per simulation
+weights_summary = meta_df.groupby("sim_label").agg(
+    total_weight=("final_weight", "sum"),
+    event_count=("final_weight", "count")
+).reset_index()
+
+print(weights_summary.to_string(index=False))
 ```
 
 **Expected output:**
 ```text
-Physical parameters:
-  tE_helio        : 3.554 days
-  u0lens1         : -1.830
-  Lens_Mass       : 0.004 M☉
-  Lens_Dist       : 8.3 kpc
-  Source_Is_Binary: 0
-  χ²              : 66.7
+     sim_label  total_weight  event_count
+RMDC26_1S1L_ML  59492.119963       294728
+RMDC26_1S2L_ML   1490.050405        29656
+RMDC26_2S2L_ML    789.135800        17356
 ```
 
-### 8. In the Browser (SQL Console)
-
-For quick exploratory data analysis without writing any code:
-
-1. Go to [RGES-PIT/MachineLearning](https://huggingface.co/datasets/RGES-PIT/MachineLearning)
-2. Click the **Dataset Viewer** tab
-3. Click the **SQL Console** button
-
-This runs DuckDB WASM entirely in your browser — type SQL directly against the remote Parquet files. Select a config from the dropdown (e.g. `observations`) and query using the config name:
-
-```sql
-SELECT 
-    COUNT(DISTINCT event_id) AS n_events,
-    COUNT(*) AS n_observations,
-    AVG(flux_uJy) AS avg_flux,
-    AVG(true_flux_uJy) AS avg_true_flux
-FROM observations
-```
-
-**Expected output table:**
-```text
-┌──────────┬──────────────-┬─────────────┬─────────────────┐
-│ n_events │ n_observations│  avg_flux   │  avg_true_flux  │
-├──────────┼──────────────-┼─────────────┼─────────────────┤
-│      610 │   30,187,680  │   50.738523 │       50.738970 │
-└──────────┴──────────────-┴─────────────┴─────────────────┘
-```