Upload README.md

README.md

@@ -13,6 +13,27 @@ configs:
 
 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
+
+```
+┌───────────────────┐        ┌───────────────────┐        ┌───────────────────┐
+│     metadata      │        │   observations    │        │      epochs       │
+├───────────────────┤        ├───────────────────┤        ├───────────────────┤
+│ event_id (PK)     │◄───────├ event_id (FK)     │    ┌──►│ epoch_id (PK)     │
+│ name              │        │ epoch_id (FK) ────┼────┘   │ bjd               │
+│ sim_label         │        │ filt              │        │ obs_x             │
+│ tE_helio          │        │ flux_uJy          │        │ obs_y             │
+│ u0lens1           │        │ flux_err_uJy      │        │ obs_z             │
+│ …(physical params)│        │ true_flux_uJy     │        └───────────────────┘
+└───────────────────┘        │ saturation_flag   │
+                             └───────────────────┘
+```
+
+**Relationships:**
+- **observations → metadata**: many-to-one on `event_id` (each event has one metadata record)
+- **observations → epochs**: many-to-one on `epoch_id` (each epoch has many observations)
+- To reconstruct a full lightcurve: join all three tables on `event_id` and `epoch_id`
+
 ## Tables
 
 ### 1. Observations Table (`_obs.parquet`)
@@ -35,20 +56,20 @@ Contains the "ground truth" and physical parameters for each event.
 | :--- | :--- | :--- |
 | `name` | string | Unique event identifier (e.g., `RMDC26_XXXXXX`). |
 | `event_id` | int64 | Integer ID matching the observations table. |
-| `sim_label` | string | Simulation category (e.g., `RMDC26_SINGLE`). |
+| `sim_label` | string | Simulation category (e.g., `RMDC26_1S1L_ML`). |
 | `SubRun` | float64 | Sub-run identifier. |
 | `Field` | float64 | Field identifier. |
 | `EventID` | float64 | Event ID. |
 | `final_weight` | float64 | Population weight for the event. |
-| `ObsGroup_0_chi2` | float64 | Fit quality indicator ($\chi^2$). |
+| `ObsGroup_0_chi2` | float64 | Delta ($\chi^2$) between the best fitting single lens model and the true model. |
 | `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. |
-| `piEN` | float64 | Parallax-North term. |
+| `piEE` | float64 | Parallax-East term. In equitorial co-ordinates. |
+| `piEN` | float64 | Parallax-North term. In equitorial co-ordinates.|
 | `piEll` | float64 | Parallax-parallel term. |
 | `piErp` | float64 | Parallax-perpendicular term. |
 | `rE` | float64 | Einstein radius. |
@@ -124,9 +145,9 @@ Contains unique spatio-temporal definitions for every observation epoch.
 
 **Event Complexity:**
 - There are three simulations included in this dataset:
-    - `RMDC26_SINGLE`: Single lens and single source events.
-    - `RMDC26_CPSQ610100`: One star - one planet lens and single source events.
-    - `RMDC26_CPSQ600100`: One star - one planet lens and binary source events.
+    - `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. 
 
 **Dataset Structure:**
@@ -135,3 +156,299 @@ 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.
 
+## 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)
+
+```bash
+pip install duckdb huggingface_hub
+```
+
+Set your Hugging Face token (get one at https://huggingface.co/settings/tokens):
+
+```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
+
+```python
+from datasets import load_dataset
+import os
+
+token = os.environ.get("HF_TOKEN")
+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()
+
+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
+```
+
+### 3. Query with DuckDB and return a pandas DataFrame
+
+You can also fetch results directly as a pandas DataFrame for further analysis:
+
+```python
+import duckdb
+from huggingface_hub import HfFileSystem
+
+duckdb.register_filesystem(HfFileSystem())
+
+df = duckdb.sql("""
+    SELECT 
+        o.event_id,
+        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
+""").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()
+```
+
+**Expected output:**
+```text
+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
+
+```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.
+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
+```
+
+### 6. Subsample for faster exploration
+
+```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")
+```
+
+**Expected output:**
+```text
+Subsampled to 100,000 observations
+```
+
+### 7. Access ground-truth parameters for an event
+
+```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}")
+```
+
+**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
+```
+
+### 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 │
+└──────────┴──────────────-┴─────────────┴─────────────────┘
+```
+
+