Datasets:

dsaaf
/

HLS-LST-CrossSensor

+# HLS–LST 数据集文档
+文档更新：2026-09-14。HLP 新增独立验证划分 v2，数据总成员保持不变；全量规模与分布统计截至2026-09-12，全量图像与超分基线统计完成于2026-09-13。本文说明数据内容、来源、配对、划分和读取约定，原有分布统计保留在附录。
+## 1. 数据集命名与概况
+采用共同前缀 **HLS-LST** 和描述性后缀作为本项目的统一工作名称。它们是本文的数据标识，不表示已注册的公开数据集名称，也不暗示与某个模型绑定。
+| 文档名称 | 简短描述 | 历史名称 / 读取器 ID | MGRS tiles | HLS 样本 | fine LST 样本 | 当前存储 |
+|---|---|---|---:|---:|---:|---|
+| **HLS-LST-Pairs（HLP）** | HLS 光学与 fine LST 的 patch 配对记录 | Prithvi Data / `prithvi` | 3,094 | 242,416 | 242,416 | 无损压缩包115.61 GiB |
+| **HLS-LST-CrossSensor（HLC）** | MODIS coarse LST 与 Landsat fine LST 的 patch 配对记录，附 HLS 条件影像 | LSTSR-TB / `lstsr_tb` | 2,490 | 277,808 | 2,892,007 | 数据目录403.57 GiB |
+HLP为本项目自行构建的HLS–Landsat温度配对数据。用户提供的下载脚本自述参考Prithvi-EO-2.0的tile采样思路；这解释了旧目录名，不表示数据由Prithvi模型生成或由其团队发布。`Prithvi Data`仅作为来源目录与实验兼容别名保留。文档名称调整不更改已有文件路径、读取器 ID、检查点或冻结指纹。2026-09-14 新增的 HLP 验证划分单独保存为 v2 索引与归一化版本，复用原压缩数据；旧 v1 保留供历史复现。HLC 原字段 `sequence_id` 继续作为标识符，本文称其对应对象为 **月份集合（calendar-month bundle）**。
+计数单位：HLP 一条记录为一对 HLS/fine LST patch；HLC 一条月份集合含一份 HLS 和6–12个可用 coarse–fine LST 月份对。HLC 的2,892,007指可用 patch-month 对数，不把 coarse、fine 两端重复计数，也不等于独立卫星场景数。两套数据均未按跨数据集内容重复去重。存储体积为文件逻辑大小，压缩包与目录的体积口径不同。
+### HLC 后续训练空间裁剪约定（2026-09-30）
+后续合成退化实验统一从256×256取固定中心224×224：行列均为`[16:240]`，同一sequence各月份以及所有epoch均保持相同窗口，HLS/fine LST/mask同步，禁用随机翻转。合成coarse LST在裁剪后生成。新入口为`experiments/efdiff_hlc/center_data.py`，机器可读协议见[center_crop_protocol.json](../experiments/efdiff_hlc/center_crop_protocol.json)。原始数据及train/val/test成员不变。此前HLC扩散实验为逐月随机裁剪训练、中心裁剪验证；历史结果和代码不覆盖。新增入口已准备，不表示已启动中心裁剪重训。
+## 2. Sensor / Product Provenance
+以下区分“下载代码确认”“本地记录可追溯”“抽样支持”和“尚待补证”。第一套下载代码实际位于`lst-super-resolution/data_download/`，已保存[只读代码快照及来源核对](HLP_SOURCE_PROVENANCE.md)。产品官方网站用于解释产品定义；当前代码快照也不替代每个历史样本的源景记录。
+| 数据集 / 模态 | 卫星与传感器 | 产品与波段 | 本地来源证据与边界 |
+|---|---|---|---|
+| HLP / HLS 光学 | **Landsat 8 / OLI、Landsat 9 / OLI-2**的L30产品来源；未逐样本统计两者比例 | **NASA HLSL30 v2.0**，`NASA/HLS/HLSL30/v002`，`B2`–`B7`及`Fmask`；没有使用HLSS30/Sentinel-2分支 | `common.py`固定collection，`download_patches.py`只查询HLSL30；metadata保留选中影像的`hls_image_id`。[HLS产品定义](https://developers.google.com/earth-engine/datasets/catalog/NASA_HLS_HLSL30_v002) |
+| HLP / fine LST | **Landsat 8 / TIRS、Landsat 9 / TIRS-2** | **USGS Landsat Collection 2、Tier 1、Level-2 Surface Temperature**，`LANDSAT/LC08/C02/T1_L2`与`LANDSAT/LC09/C02/T1_L2`合并后取`ST_B10` | 下载代码明确执行温度转换、按时间距离排序后mosaic并导出到HLS网格；metadata仍缺实际贡献的LST场景ID与时间。另有[单位核验](../experiments/data/LST_ENCODING_VERIFICATION.md)，18个抽样位置差异均≤0.02°C |
+| HLP / coarse LST | 无独立实测来源 | 当前交付不含 coarse LST；需要实验时由 fine LST 合成退化生成 | 必须标作 synthetic coarse LST，不能称为 MODIS 配对 |
+| HLC / HLS 光学 | **Landsat 8 / OLI**，由上游 `LC08` 选择条件限定 | **NASA HLSL30 v2.0**，`NASA/HLS/HLSL30/v002`，`B2`–`B7`，附 `Fmask` | 全部277,808条 HLS manifest 均指向该 collection；配置 `landsat_product_prefix=LC08`。HLSL30产品整体支持Landsat 8/9，但本数据选择范围只含Landsat 8。[HLS产品定义](https://developers.google.com/earth-engine/datasets/catalog/NASA_HLS_HLSL30_v002) |
+| HLC / fine LST | **Landsat 8 / TIRS、Landsat 9 / TIRS-2** | **USGS Landsat Collection 2、Tier 1、Level-2 Surface Temperature**；来源ID为 `LANDSAT/LC08/C02/T1_L2` 或 `LANDSAT/LC09/C02/T1_L2`，对应温度波段 `ST_B10` | 月份来源表保留 `landsat_scene_ids`、`primary_scene_id` 与采集时间。目标可由主景及同日辅助景填补组成，并非每个patch-month都只有唯一Landsat源景。[USGS产品说明](https://www.usgs.gov/landsat-missions/landsat-collection-2-surface-temperature) |
+| HLC / coarse LST | **Terra / MODIS** | **MOD11A1 Collection 6.1**，`MODIS/061/MOD11A1`，日间LST `LST_Day_1km`；附日间QA、观测时间和观测角层 | `modis_image_id` 可追溯至每日产品，数组保留 `lr_qc_day`、`lr_view_time_h_x10`、`lr_view_angle_deg`。不是 Aqua/MYD11A1，也不是由 fine LST 降采样得到。[MOD11A1产品说明](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MOD11A1) |
+HLS是光学地表反射率产品来源，不是本文 fine LST 的反演来源。Landsat Surface Temperature 是卫星反演参考产品，不应称为无误差地面真值，也不是由 HLS 反射率直接提供的温度波段。
+HLP现已确认collection、温度公式、目标网格、时间检索和选tile算法；剩余缺口是历史运行版本/输入清单、逐样本LST贡献场景与时间、以及未写入metadata的CRS和仿射变换。HLC温度来源有同日多景与填补信息，但本次提供的是第一套下载代码，不能用它代替HLC导出实现；HLC精确像元源景归属、全部QA/填补阈值与fine重采样核仍待补齐。
+## 3. Coarse / Fine Resolution 与配对关系
+### 3.1 分辨率术语
+统一使用 **coarse-resolution LST** 与 **fine-resolution LST**，表示本任务中相对粗、细的输入/参考网格。原始字段 `lr_*`、`hr_*` 为兼容保留，文档分别解释为 coarse、fine。
+| 内容 | 存储形状 | 网格与物理分辨率的解释 |
+|---|---|---|
+| HLP HLS / fine LST | `6×256×256` / `256×256` | 下载代码取选中HLSL30的`B2`原生投影与仿射变换，以同一30 m产品网格导出HLS和LST，再同位置裁剪；每patch约7.68 km×7.68 km。实际变换未存入patch metadata，不能按目录tile盲目重建 |
+| HLC HLS / fine LST | `6×256×256` / 每月`256×256` | 当前月份元数据的fine网格步长均为30 m；patch覆盖约7.68 km×7.68 km |
+| HLC coarse LST | 每月`8×8` | 源MOD11A1为名义1 km产品；配置倍率32，按同范围网格推算目标采样间隔为960 m。它是重投影后的coarse网格，不能描述成MODIS原生960 m观测 |
+**30 m产品网格不等于30 m原生热红外观测。** Landsat 8/9热红外波段以100 m采样并重采样到30 m产品网格；本数据的32×是`256/8`的数组边长比，不是独立热信息量提高32倍。[USGS传感器与采样说明](https://www.usgs.gov/centers/eros/science/usgs-eros-archive-landsat-archives-landsat-8-9-operational-land-imager-and)
+### 3.2 HLP：光学–温度配对
+连接键为原记录路径对应的 `(split, tile, obs_idx, row, col)`；同一冻结记录包含 `bands.npy`、`fmask.npy`、`lst.npy` 和 `metadata.json`。下载代码证明二者请求同一HLS网格并按同一行列裁剪，不代表独立测量的配准精度。
+`metadata.datetime`来自Phase 2的HLS候选观测清单，是Phase 3检索锚点，**不是LST采集时间**。以其日历日D为基准，HLS检索`[D−3天, D+4天)`，按`CLOUD_COVERAGE`最小选一景；LST检索`[D−1天, D+2天)`，合并Landsat 8/9，按距离锚点的时间差降序排列后`mosaic()`，使较近时刻的有效像元优先，并允许其他候选填补。窗口按日期截断、右端不包含；不能写成严格同日配对，也不能把mosaic称为多景平均。[GEE日期边界](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-filterdate)与[mosaic优先级](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-mosaic)。
+HLS查询按目标bbox的中心点`filterBounds`，没有强制场景tile ID等于目录tile。选中影像的`B2`投影用于两种模态，解释了目录tile与HLS ID可能不一致的生成机制；这仍需逐样本源网格复核。`row,col`定位的是所选HLS网格，不能仅用目录tile推断精确位置。LST导出未显式调用`resample()`，依GEE默认重投影行为解释为最近邻，不能声称实施了双线性导出。[重采样规则](https://developers.google.com/earth-engine/guides/resample)
+### 3.3 HLC：真实 coarse–fine 配对与 HLS 条件
+一个可用样本由 `(sequence_id, calendar_month)` 标识；该月份对应实际 `date`。其输入/参考关系为：
+```text
+同一可用月份：Terra/MODIS coarse LST [8,8]
+           + 该月份集合共用的 HLS 光学 [6,256,256]
+           → Landsat fine LST 参考 [256,256]
+```
+温度两端按同一日历日选择来源，全量可用月份对应的MODIS产品日期与月份来源日期一致；这不是同时刻观测保证。清单另保留传感器时间差与有效性统计。MODIS导出记录为 `nearest` 重采样到任务网格。fine/coarse各有独立有效mask；同日、同网格设计仍不消除传感��响应、观测时刻、反演误差和剩余配准误差。
+每条月份集合只有**一份HLS**，通过 `sequence_id` 与温度文件及manifest连接，并非每个月独立配一份同期HLS。HLC全量HLS与目标温度日期差中位数为728天，71.83%的月份样本超过365天；这说明辅助光学的时相条件，不等于几何错位，也不单独证明误差原因。历史统计中HLP的0天中位数实际比较“选中HLS日期”与“HLS候选检索锚点”，不测量HLS与实际LST贡献景的时间差，因此不能与HLC的728天作同一物理含义的日期比较。详见[原始日期统计](lst_hls_sr_census_20260913/full_date_alignment.json)和[新代码解释](HLP_SOURCE_PROVENANCE.md)。
+空间定位使用 `grid_crs`、`grid_transform` 和patch像素偏移 `x0,y0`；`patch_row/patch_col` 是裁剪网格索引。相同MGRS tile ID不保证相同裁剪范围；当前仅核验存储结构、来源元数据和索引一致性，未完成全量独立几何配准误差测量。
+## 4. Calendar-month Bundle：不是连续 Time Series
+HLP的基本单位是一次光学–温度配对记录。按 `(tile,row,col)` 归组只能得到候选重复位置记录，不应直接称为已配准、连续的时间序列。
+HLC的 `sequence_id` 是存储键，`sequence_mode=calendar_month_bundle_independent_same_day_pairs`，`storage_grouping=twelve_calendar_month_bundle_cross_year_allowed`。轴0对应1–12月槽位；每月选择一次实际日期的温度配对，不是月平均，也不是固定年份的12个月。
+例如 `T01WCP_v000_p0000` 的3月取自2021-03-30，4月取自2024-04-06，8月取自2022-08-08；月份轴不按实际时间递增。其2月虽在 `month_dates_json` 中有候选日期，却不在该patch的 `available_months` 中，因此不得把“日期非空”作为可用样本条件。
+读取时先用 `available_months` 决定可用槽位，再使用fine/coarse有效mask。不要补零后当有效温度，也不要默认“上一槽位”是相邻时间。使用时间模型需显式提供实际日期/时间差、限制可用条件，并检查时序任务所需的时空一致性；当前数据不直接提供严格连续、固定间隔的时序预测基准。
+## 5. Train / Validation / Test Split
+| 数据集 | 文档划分 | 源split/API标签 | tiles | HLS/记录或月份集合数 | fine LST样本数 |
+| --- | --- | --- | --- | --- | --- |
+| HLP | 训练 | 源 train → train | 2,796 | 218,975 | 218,975 |
+| HLP | 验证 | 源 train → val | 147 | 11,684 | 11,684 |
+| HLP | 测试 | 源 val → test | 151 | 11,757 | 11,757 |
+| HLP | 合计 | —（汇总） | 3,094 | 242,416 | 242,416 |
+| HLC | 训练 | train | 2,249 | 250,449 | 2,608,772 |
+| HLC | 验证 | val | 118 | 13,694 | 141,711 |
+| HLC | 测试 | test | 123 | 13,665 | 141,524 |
+| HLC | 合计 | —（汇总） | 2,490 | 277,808 | 2,892,007 |
+**HLP 当前划分（v2，2026-09-14）：**从旧训练集的2,943个MGRS tiles中，以固定种子`20260914`，按`(SHA256("20260914:" + tile_id), tile_id)`升序排列，取前`round(0.05×2943)=147`个tiles作为独立validation。同一tile的全部HLS/fine LST配对整体移动；新训练为2,796个tiles、218,975对，验证为147个tiles、11,684对。原测试的151个tiles、11,757对成员固定。三份集合的记录ID和MGRS tile ID两两无交集，train∪val精确等于旧train；测试索引数组与旧源val逐项相同。[划分协议与读取](hlp_split_20260914/README.md)、[精确计数与校验](hlp_split_20260914/split_summary.json)、[生成脚本](../experiments/data/create_hlp_validation.py)。
+新读取版本为`processed_data/hlp_split_v2_20260914`，API split直接使用`train/val/test`。旧`processed_data/v1`仍保持源`train/val`标签，其中旧`val`为测试；原记录路径和压缩包内部metadata的split继续表示来源，派生索引额外记录`source_split/experiment_split`。必须显式传入新`prepared`路径，不能把旧版本的`val`误当新验证集。
+新归一化仅拟合剩余218,975条训练记录：使用旧训练集保存的未四舍五入充分统计量，减去对全部11,684条新验证记录从原压缩字节重新计算的一阶/二阶矩之和及有效像元计数，再生成mean/std；沿用原像元mask与样本等权规则。验证、测试共用新训练统计，不继续使用包含新验证成员的旧归一化。[计算明细](hlp_split_20260914/normalization_derivation.json)。这采用float64求和与相减，存在通常的浮点舍入误差。
+此划分用于今后的独立训练与选模。旧模型曾在原训练池中见过新验证成员，历史实验也曾监测旧源val（测试成员）；新划分不会追溯消除这些使用记录。新实验应从零训练或使用未见过此数据的初始化，验证用于选模，固定测试用于最终评价。
+**HLP 原始训练/测试来源：**现已找到Phase 1算法：先依据2019年Copernicus土地覆盖和RESOLVE 2017生态区选tile，包括类别抽样、城市/高熵区域补充与生态区补齐，再按dominant LULC分层打乱，每类取`max(1, int(n_class×0.05))`个tiles进入源val，其余进入train。当前入口传入`seed=42`。这不是全体patch随机95/5划分；同tile全部记录继承其split。当前脚本与历史导出的逐tile成员尚未用原`selected_tiles.csv`完整重放核对，最终成员以冻结索引为准。[代码与复现边界](HLP_SOURCE_PROVENANCE.md)
+HLP另有Phase 4海洋/沙漠约10%下采样及位置排重代码，但该阶段只输出样本清单；未获得证明当前242,416条冻结记录采用了该清单的证据，不能把此筛选写成已应用的数据属性。当前独立验证划分已按上述v2落实；调参使用新validation，不能使用固定test选模型。
+**HLC：**原持出集合于2026-09-05由源`val`更名为`test`，成员不变。随后从原训练的2,367个MGRS tiles中，按 `SHA256('20260905:' + tile_id)` 排序，取前118个tiles（`round(0.05×2367)`）作为validation；其余2,249个tiles用于train，原123个test tiles固定。一个tile下所有patch、月份集合和月份样本整体进入同一split。原持出test集合最初的选tile规则尚缺，不能将其描述为同一哈希算法生成。[划分协议](extracted_metadata/lstsr_tb_final_dataset_20260719/splits/README.md)与[精确清单/校验记录](extracted_metadata/lstsr_tb_final_dataset_20260719/splits/split_summary.json)。
+两套数据各自的split之间MGRS tile ID不重叠；这不是逐像元空间零重叠证明，也不是跨年份留出。相邻tile边缘重叠、相同源景的跨tile关系需单独核验。两套数据之间共有1,767个tile ID；联合训练/跨数据集测试时不能据此假定彼此独立。
+归一化参数仅由各自训练集、各自模态计算，validation/test复用。不得使用测试目标拟合温差校准、选择退化参数或调参。原始split名称保留在统计/索引文件中时，以本节的语义映射解释。
+## 6. Dataset Structure / Schema
+### 6.1 存储结构与关系表
+```text
+HLP 原逻辑记录（当前打包为可随机访问的无损 EOZ / ZIP）
+  <source_split>/<tile>/obs_<id>/r<row>_c<col>/
+    bands.npy | fmask.npy | lst.npy | metadata.json
+  当前包：artifacts/prithvi_data_v1_20260909.zip
+  当前索引：processed_data/hlp_split_v2_20260914/prithvi/index.sqlite
+  历史索引：processed_data/v1/prithvi/index.sqlite（仅train/源val）
+HLC 根目录：data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/
+  arrays/<tile>/<sequence_id>.npz                         # coarse/fine 温度与QA
+  phase4_dataset_manifest.csv                            # 一行一个月份集合
+  phase3_tile_variant_months_merged.csv                   # 一行一个variant×月份
+  hls_l8_conditions_2019_2025_lc08/
+    arrays/<tile>/<sequence_id>.npz                       # 单份光学条件
+    hls_condition_manifest.csv                           # 一行一个光学条件记录
+    hls_condition_config.json
+  splits/                                               # 当前成员清单及split协议
+```
+| 关系表 / 字段 | 含义与连接规则 |
+|---|---|
+| HLP metadata | `tile, split, obs_idx, row, col, datetime, patch_size, bands, bands_dtype, bands_scale, hls_image_id, has_lst, lst_dtype, lst_scale`；记录路径唯一标识一次配对 |
+| HLC `sequence_id` | 月份集合主键；temperature manifest与HLS manifest按此一对一连接；不是连续时间序列认证 |
+| `tile_variant_id, month` | 温度来源表连接键；`month`为1–12；每个patch只读取自身`available_months` |
+| `mgrs_tile, patch_idx, patch_row, patch_col, x0, y0` | 区域、patch标识和像素偏移；结合来源表的CRS/仿射变换定位 |
+| `available_month_count, available_months, missing_months` | patch层面的可用性；`source_available`只描述上一级来源候选，不足以替代patch可用性 |
+| `month_dates_json, month_landsat_times_json` | 月份对应的实际来源日期与Landsat时间；不将月份编号当连续时间坐标 |
+| `landsat_scene_ids, primary_scene_id, modis_image_id` | 温度两端来源；一份fine参考可能涉及多个Landsat场景 |
+| `hls_collection, hls_asset_id, hls_image_id, hls_datetime_utc` | 光学产品、完整资产标识与独立采集时间 |
+| `split, archive, schema_version / *_schema_version` | 当前划分、相对数组路径和格式版本；不同manifest的`archive`相对各自目录解释 |
+### 6.2 Array Schema
+以下为原始存储数组；读取器输出的归一化tensor不是同一编码。HLC字段形状与dtype已读取实际样本确认，完整性沿用全量索引与已有验收；本次没有重做每个辅助QA数组的全量逐值审计。HLP当前下载代码还可选写`qa_pixel.npy`（`[256,256] uint16`），并允许QA请求失败后保存温度；该层不在已冻结四文件格式内，不能据当前代码声称它已随本地数据交付。
+| 数据 | 字段 | Shape | dtype | 说明 |
+|---|---|---|---|---|
+| HLP | `bands.npy` | `[6,256,256]` | `int16` | 六波段光学，通道顺序见下节 |
+| HLP | `fmask.npy` | `[256,256]` | `uint8` | 光学质量bitmask |
+| HLP | `lst.npy` | `[256,256]` | `int16` | fine LST，填充值`-32767` |
+| HLC | `hr_lst` / `hr_valid` | `[12,256,256]` | `int16` / `uint8` | fine LST及有效性；无效温度填充值`-32768` |
+| HLC | `lr_lst` / `lr_valid` | `[12,8,8]` | `int16` / `uint8` | coarse LST及有效性；无效温度填充值`-32768` |
+| HLC | `hr_st_qa_k_x10`, `hr_flags` | `[12,256,256]` | `uint8` | fine温度QA辅助层；`hr_flags`位定义与QA饱和/填充值约定仍需原导出说明 |
+| HLC | `lr_qc_day`, `lr_view_angle_deg`, `lr_view_time_h_x10` | `[12,8,8]` | `int16` | coarse日间QA、观测角及时间辅助层；先核对源编码/填充值再解码 |
+| HLC | `hls_reflectance_i16` | `[6,256,256]` | `int16` | 单份光学条件，填充值`-32768` |
+| HLC | `hls_valid`, `hls_fmask` | `[256,256]` | `uint8` | 光学有效性及Fmask |
+| HLC | `source_time_s`, `candidate_rank` | scalar | `int64` / `uint8` | HLS Unix秒级时间与候选排序序号 |
+### 6.3 单位、波段与有效性
+- 光学通道固定为 **Blue、Green、Red、NIR、SWIR1、SWIR2**；两套下载来源均对应HLSL30的`B2,B3,B4,B5,B6,B7`。反射率为存储整数乘`0.0001`，当前读取器不额外裁剪。**HLP下载端已执行`clip(0,10000)`**，因此“不额外裁剪”不能解释成上游没有裁剪；HLC不从该第一套代码推定处理方式。
+- 两套fine LST采用`stored / 100.0`恢复摄氏度；HLC coarse LST沿用相同摄氏度×100编码解释。原始Landsat DN与MODIS DN各有不同缩放，不能再套用于已经转换后的这些数组。fine单位有抽样源像元核验，coarse另有来源与整数步长证据，见[编码核验记录](../experiments/data/LST_ENCODING_VERIFICATION.md)。
+- HLP光学有效条件：六波段无`-9999/-32767/-32768`填值，`Fmask != 255`，且`(Fmask & 14) == 0`。HLC还与`hls_valid`取交集。bits 1–3对应云、邻云/阴影邻域、阴影；零值、雪、水与气溶胶不在当前读取器中额外全部剔除。Fmask只约束光学，不替代LST QA。
+- HLP温度按`lst != -32767`；HLC分别使用`hr_valid & (hr_lst != -32768)`和`lr_valid & (lr_lst != -32768)`。任务评分使用实际所需模态的有效支持；插值还需有效coarse邻域，不能把所有数组像元当有效配对。
+- HLC上游HLS最终保留规则为`valid_fraction >= 0.98`且`snow_fraction + water_fraction < 0.98`。这是记录级筛选，不意味着每个保留patch完全无雪、无水或没有无效像元。不能直接把该规则归给HLP。
+HLP下载端另外按每波段缺失比例≤1%、patch的Fmask bits 0–3并集比例≤20%筛选；fine温度只保留`[-50,70]°C`内数值，并要求patch缺失≤1%。这些是下载代码中的记录级筛选，与当前读取器的像元mask分开解释。代码下载`QA_PIXEL`但未用其bit位额外去除LST云/阴影；“温度落在范围内”不等于经过完整LST质量认证。
+### 6.4 读取器与任务样本的区别
+现有`eo_data`入口按单模态返回归一化`image/target`及mask，当前`target`是自重建目标；LST模态展开可用fine月份。它**不是已经封装好的**`(coarse LST, HLS, fine LST)`三元组加载器。构建引导任务时，需要按上述键读取对应coarse数组和HLS，并保持split、月份与mask同步。
+```python
+from eo_data import open_dataset
+prepared = 'processed_data/hlp_split_v2_20260914'
+ds = open_dataset('prithvi', 'lst', 'val', prepared=prepared)  # HLP独立验证集
+# 测试集使用 split='test'；新训练集使用 split='train'，均传同一prepared。
+sample = ds[0]
+temperature_c = ds.denormalize(sample['image']) / 100.0
+valid = sample['reference_mask']           # 无效位置仍必须排除
+```
+`image`已做z-score，不能直接除以100当温度。接口与存储恢复方式详见[统一读取说明](../eo_data/README.md)；其中旧v1的`prithvi/val`为测试，新v2的`prithvi/val`为独立验证；按prepared版本区分。
+## 7. Supported Tasks
+| 任务 | HLP | HLC | 使用条件 |
+|---|---|---|---|
+| 光学引导LST空间细化：coarse LST＋HLS → fine LST | 可构造合成coarse输入 | 可使用真实MODIS或受控合成coarse输入 | 统一退化、网格和mask；真实跨传感器与合成任务分开报告 |
+| 仅LST的空间细化：coarse → fine | 需合成退化 | 真实与合成均可 | fine是参考产品，不是无误差真值；倍率明确为网格倍率 |
+| HLS或LST的表示学习、压缩、自编码重建 | 支持 | 支持 | 按各自训练split拟合；避免HLC重复展开月份时把同一HLS误算成独立观测 |
+| 光学条件温度估计：HLS → fine LST | 可做配对回归实验 | 可做跨时相条件估计实验 | 日期不严格一致；不包装为已验证的同步温度反演基准 |
+| 掩码重建、人工缺失/噪声鲁棒性 | 可构造 | 可构造 | 只在原本有效位置合成并保留未扰动参考；原生缺失区没有自动获得真值 |
+| 按月份/年份/区域分析与不规则多观测建模 | 重复位置记录有限 | 可使用实际日期的月份集合 | 不宣称直接支持连续时间预测、严格连续变化检测或未来预测基准 |
+没有地面实测温度、土地覆盖分类标签或严格连续时序标签时，不把相关任务写成现成监督基准。当前全量超分基线是固定32×方法的诊断，不是数据集固有难度常数；模型、训练样本量、时间条件或退化变化后需重新评价。
+## 8. Evidence、版本与待补信息
+当前统计以冻结索引、最终保留manifest及全量验收为准；旧合并/下载文档中的2,517个tiles等中间数量不代表当前HLC。以下资料均保留原兼容名称：
+- [规模与分布原始统计](final_dataset_stats.json)：全量记录、月份、地理分组与历史各split计数；其中HLP旧源`val`对应test，旧train尚未拆出新validation；当前HLP split计数以[v2划分记录](hlp_split_20260914/split_summary.json)为准。
+- [本次来源与schema核对](dataset_documentation_audit.json)：当前HLC全量manifest的collection、同日关系、网格、重采样记录，以及一个实际bundle的数组schema。
+- [HLP下载代码来源核对](HLP_SOURCE_PROVENANCE.md)、[代码快照与SHA-256](provenance/hlp_download_20260913/source_manifest.json)：产品、采样、split、日期锚点、mosaic、网格与上游质量处理。
+- [HLC HLS构建配置](extracted_metadata/lstsr_tb_final_dataset_20260719/hls_l8_conditions_2019_2025_lc08/hls_condition_config.json)、[HLC split协议](extracted_metadata/lstsr_tb_final_dataset_20260719/splits/README.md)。
+- [LST单位核验](../experiments/data/LST_ENCODING_VERIFICATION.md)、[HLP已有来源配对检查](prithvi/source_alignment.json)。
+- [全量温度复杂度统计](lst_sr_census_20260913/REPORT_ZH.md)、[coarse LST＋HLS全量评估](lst_hls_sr_census_20260913/REPORT_ZH.md)、[全量索引/光学一致性验收](lst_hls_sr_census_20260913/coverage_audit.json)。历史结果中的`synthetic_lr/native_lr/hr`字段分别按合成coarse/真实coarse/fine解释。
+尚待补齐：HLP历史执行版本与选tile清单、实际LST贡献景/时间及逐patch地理变换；HLC最初持出test的选择规则与完整温度导出/QA说明；两套的全量独立配准与跨split footprint重叠核验。HLP下载算法与候选产品来源已由新代码确认，不再列为完全未知。派生数据集自己的作者署名、许可、版本发布与引用标识尚待整理，不从源产品许可或历史模型名推定。
+## 附录A. 全量空间分布
+按目录/清单MGRS tile编码的纬度带归组，绝对纬度带边界统一为32°和64°，不同于旧HLC按中心纬度30°/60°的分组。该统计不是精确patch边界或国家覆盖范围；MGRS规则见[NGA官方说明](https://earth-info.nga.mil/?action=coordsys&dir=coordsys)。
+| 数据集 | 绝对纬度带 | tiles | HLS样本 | fine LST样本 |
+| --- | --- | --- | --- | --- |
+| HLP | 0°–32° | 1,391 | 110,093 | 110,093 |
+| HLP | 32°–64° | 1,469 | 117,666 | 117,666 |
+| HLP | ≥64° | 234 | 14,657 | 14,657 |
+| HLC | 0°–32° | 1,063 | 102,855 | 1,067,426 |
+| HLC | 32°–64° | 1,247 | 166,875 | 1,764,632 |
+| HLC | ≥64° | 180 | 8,078 | 59,949 |
+| 数据集 | 半球 | tiles | HLS样本 | fine LST样本 |
+| --- | --- | --- | --- | --- |
+| HLP | 北半球 | 2,428 | 191,638 | 191,638 |
+| HLP | 南半球 | 666 | 50,778 | 50,778 |
+| HLC | 北半球 | 1,987 | 225,859 | 2,341,943 |
+| HLC | 南半球 | 503 | 51,949 | 550,064 |
+HLP覆盖60个UTM分区，HLC覆盖58个。共有1,767个相同tile ID，跨数据集去重后为3,817个tile ID；相同ID不代表相同patch或时相。HLP每tile含1–92条记录，均值78.35；HLC每tile含1–196个月份集合，均值111.57。HLC清单中心纬度范围为52.86°S–78.80°N；HLP缺少可直接核验的精确坐标字段，不报告精确纬度端点。
+## 附录B. 年份与日历月份分布
+HLP HLS按场景ID日期统计；`metadata.datetime`经下载代码确认是HLS候选观测的检索锚点，不是LST贡献景采集时间。HLC HLS按自身采集时间，温度仅按可用月份的实际来源日期统计。
+| 年份 | HLP HLS | HLP检索锚点 | HLC HLS | HLC fine LST |
+| --- | --- | --- | --- | --- |
+| 2014 | 16,916 | 16,916 | 0 | 0 |
+| 2015 | 17,422 | 17,422 | 0 | 0 |
+| 2016 | 15,480 | 15,480 | 0 | 0 |
+| 2017 | 14,083 | 14,083 | 0 | 0 |
+| 2018 | 14,792 | 14,792 | 0 | 0 |
+| 2019 | 15,197 | 15,197 | 45,735 | 178,032 |
+| 2020 | 14,779 | 14,779 | 42,688 | 163,634 |
+| 2021 | 16,408 | 16,316 | 36,675 | 225,980 |
+| 2022 | 29,182 | 29,274 | 48,513 | 603,165 |
+| 2023 | 27,474 | 27,474 | 31,436 | 644,785 |
+| 2024 | 27,651 | 27,661 | 41,572 | 554,132 |
+| 2025 | 29,575 | 29,565 | 31,189 | 522,279 |
+| 2026 | 3,457 | 3,457 | 0 | 0 |
+| 合计 | 242,416 | 242,416 | 277,808 | 2,892,007 |
+HLP记录日期范围2014-01-01至2026-02-14，2026年仅含年初；HLC HLS为2019-01-01至2025-12-29，fine LST为2019-01-01至2025-12-31。不同月份允许来自不同年份，HLS不保证与全部月份同期。
+| 月份 | HLP HLS | HLP检索锚点 | HLC HLS | HLC fine LST |
+| --- | --- | --- | --- | --- |
+| 1月 | 17,168 | 17,252 | 8,423 | 197,646 |
+| 2月 | 16,538 | 16,536 | 12,192 | 234,546 |
+| 3月 | 20,220 | 20,190 | 10,113 | 251,264 |
+| 4月 | 24,891 | 24,684 | 25,815 | 257,714 |
+| 5月 | 21,578 | 21,664 | 44,946 | 259,266 |
+| 6月 | 18,704 | 18,855 | 72,287 | 255,967 |
+| 7月 | 23,880 | 23,813 | 29,109 | 236,549 |
+| 8月 | 22,885 | 23,091 | 21,792 | 246,583 |
+| 9月 | 20,774 | 20,291 | 16,273 | 254,489 |
+| 10月 | 21,477 | 21,821 | 9,975 | 258,359 |
+| 11月 | 17,910 | 17,910 | 20,166 | 235,396 |
+| 12月 | 16,391 | 16,309 | 6,717 | 204,228 |
+| 合计 | 242,416 | 242,416 | 277,808 | 2,892,007 |
+以上均为patch样本计数，不是去重后的卫星场景数；同一场景的多个patch分别计数。
+## 附录C. 重复位置记录与月份可用性
+HLP按`(tile,row,col)`归组得到232,156个候选空间键，96.02%只有一次观测。该键不含完整地理变换，不能直接认定为已构造或严格配准的连续时间序列。
+| HLP同一空间键记录数 | 空间键数 |
+| --- | --- |
+| 1 | 222,906 |
+| 2 | 8,400 |
+| 3 | 711 |
+| 4 | 120 |
+| 5 | 17 |
+| 6 | 2 |
+| HLC可用月份槽位数 | 月份集合数 | 占比 |
+| --- | --- | --- |
+| 6 | 2,664 | 0.96% |
+| 7 | 2,873 | 1.03% |
+| 8 | 1,204 | 0.43% |
+| 9 | 61,685 | 22.20% |
+| 10 | 74,480 | 26.81% |
+| 11 | 72,509 | 26.10% |
+| 12 | 62,393 | 22.46% |
+HLC平均每个月份集合含10.41个可用月份，全部3,333,696个存储槽位中86.75%可用。12个槽位均可用的集合为62,393个（22.46%）；“槽位完整”不表示同一年连续12个月。每个月份集合固定一份HLS。
+## 附录D. HLC 合成退化 pilot 固定子集（2026-09-15）
+用户选择先在固定子集上短程比较 EFDiff-x₀ 与 EFDiff-ε。该子集属于实验资产，不改变 HLC 原 train/val/test 划分或本报告的全量计数。协议为 `efdiff-hlc-synthetic-pilot-16384-512-v1`；读取仍显式使用 `prepared="processed_data/v1"`。
+| 用途 | 有效 fine-LST patch-month | 覆盖原 split 的 tiles | 每 tile 样本数 |
+| --- | ---: | ---: | ---: |
+| pilot train | 16,384 | 2,249 | 6–8 |
+| pilot val | 512 | 118 | 4–5 |
+使用 seed=20260915，按 tile 尽量等额分配，样本不足的 tile 受容量限制，余量按固定随机顺序分配；tile 内月份样本无放回抽样。训练与验证的 record_id、tile 均无交集。清单保留原索引、record_id、月份槽位和 tile；成员哈希见[子集记录](../experiments/efdiff_hlc/pilot_membership/summary.json)。同一月份集合的 HLS 可被多个月份复用，不保证与每个月份同期。
+输入为 fine LST 经合成 Wald ×32 退化得到的 coarse LST，加关联 HLS；真实 MODIS coarse LST 不参与该实验。新的 condition/residual 统计只使用选中的16,384个训练月份拟合；验证共用训练统计，test不参与。每模型5个子集epoch、有效batch64，共1,280次更新和81,920次月份样本呈现。主对照固定第5轮EMA，并报告bicubic基线、有效像素RMSE/MAE和同样本图。该pilot不能表述成全量或已收敛的论文复现；运行状态与配置见[实验说明](../experiments/efdiff_hlc/README.md)。
+### 后续全量1轮实验（2026-09-16）
+pilot完成后，用户要求两模型尝试1个完整全量训练epoch。该新实验恢复使用HLC原train的全部2,608,772条有效月份样本（250,449份HLS/月集合、2,249 tiles），每条呈现1次；每模型40,763次更新，最后一次4条。去噪器从头初始化，Prithvi继续使用冻结预训练权重，新的condition/residual统计由完整train拟合。验证仍使用上述固定512条val，test不参与；此处“全量”仅指训练成员，不表示已评估完整val/test。数据版本和成员划分不变，预算及运行状态见[全量1轮登记](../experiments/efdiff_hlc/epoch1_run_manifest.json)。
+用户追加要求一天内完成，截止为2026-09-18 04:23 UTC。单卡准备版本由每模型两张H200的DDP版本接替；保留完整训练成员、每条一次、有效batch64和最后4条的准确加权，数据版本与归一化拟合范围不变。当前状态以[一天期限运行登记](../experiments/efdiff_hlc/deadline_run_manifest.json)为准，原全量统计分片继续复用，测速和smoke结果不作为正式训练结果。

data_inspection/HLP_SOURCE_PROVENANCE.md ADDED Viewed

	@@ -0,0 +1,51 @@

+# HLP 下载来源与实现核对
+更新日期：2026-09-13。用户提供的第一套下载实现实际位于 `C:/Users/rog/Desktop/lst-super-resolution/data_download/`。本次只读取并保存代码，没有运行下载、重新认证GEE或修改冻结数据。
+七个Python源文件已逐字节复制到[代码快照目录清单](provenance/hlp_download_20260913/source_manifest.json)，记录SHA-256与仓库提交`5f668490d976f211b192569dd941e9f88d6f4c3b`。该提交时间为2026-04-20；当前数据的下载进度记录早于此快照，因此不声称此提交就是全部242,416条记录的原始运行版本。它是用户指定的生成实现，可确认算法与产品族；逐样本历史追溯仍需原运行清单。
+## 确认的产品来源
+| 模态 / 辅助数据 | 当前下载实现 | 用途 |
+|---|---|---|
+| HLS光学 | `NASA/HLS/HLSL30/v002`，`B2`–`B7`、`Fmask` | Landsat来源的六波段光学条件；代码没有查询HLSS30/Sentinel-2 |
+| fine LST | `LANDSAT/LC08/C02/T1_L2`与`LANDSAT/LC09/C02/T1_L2`，`ST_B10` | Landsat 8/9 Collection 2 Tier 1 Level-2温度；代码合并两类来源，不意味着每个样本都同时含两卫星 |
+| LST QA | 同一候选mosaic的`QA_PIXEL` | 当前代码尝试附带下载；失败也允许保存LST，不参与该下载实现的温度逐像元云过滤 |
+| 地表覆盖 | `COPERNICUS/Landcover/100m/Proba-V-C3/Global/2019`，或本地2019年分类栅格 | tile筛选、dominant LULC分层；不是随每个patch交付的逐像元标签 |
+| 生态区 | `RESOLVE/ECOREGIONS/2017`，或本地Ecoregions2017 shapefile | tile覆盖补齐；不是温度来源 |
+证据：[常量](provenance/hlp_download_20260913/common.py)、[下载实现](provenance/hlp_download_20260913/download_patches.py)、[tile选择](provenance/hlp_download_20260913/select_tiles.py)。代码自述参考Prithvi采样策略，是本项目自行构建配对数据的依据，不是Prithvi官方数据集身份的依据。
+## 日期选择、mosaic与空间网格
+1. [Phase 2](provenance/hlp_download_20260913/build_sequences.py)按bbox中心点查询HLSL30，每季度至多取10条满足场景云量条件的候选，按日去重，必要时按排序后的日期索引`linspace`取样。[入口](provenance/hlp_download_20260913/run_pipeline.py)设置2014–2026年、每tile至多48个候选观测、场景云量`<20`。有已有CSV时会跳过重建，因此默认参数不独立证明历史执行参数。
+2. `metadata.datetime`直接取Phase 2的`observations.csv`时间，记作检索锚点t，其日历日为D。实际HLS在`[D−3天,D+4天)`重新搜索，按场景`CLOUD_COVERAGE`最小选取，不按离t最近选取；`hls_image_id`记录的是此时选中的影像。
+3. LST独立在`[D−1天,D+2天)`查询Landsat 8/9。代码将相对t的绝对时间差降序排列，再`mosaic()`。GEE从末景向前优先使用有效像元，因此较近时刻优先，较远候选可填补其掩码空缺；不是多景平均、不是保证单日或单源景的目标。[GEE mosaic定义](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-mosaic)
+4. 所有时间窗口先格式化成日期，且右端不包含。HLS与LST各自相对同一锚点搜索，不能将“±1天LST窗口”写成相对**实际所选HLS时刻**的±1天。[filterDate定义](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-filterdate)
+5. 下载从选中的HLSL30 `B2.projection()`取得CRS与六参数仿射变换；HLS和LST均以该grid请求`3660×3660`数组，再切成`256×256`不重叠patch。边长只取整到14个patch，边缘不足256像元的条带不输出。行列索引对应**实际HLS网格**。
+6. HLS查询没有强制目录tile与scene tile相等，且没有把`proj_info`写入metadata。当前代码没有为LST指定`.resample('bilinear')`或bicubic；按GEE默认规则解释为最近邻重投影。指定同网格是生成设计，不等于已独立测量的几何配准精度。[GEE重采样规则](https://developers.google.com/earth-engine/guides/resample)
+**对既有日期统计的修正：**HLP“0天中位数/91.35%同日”的分母和数值不变，但其含义是所选HLS日期与HLS候选检索锚点相比较。它不是HLS–LST采集日期差，不能与HLC实际月份温度日期的728天中位数作同义对照。LST贡献景ID、时间及逐像元来源未保存，现阶段不能从HLP metadata还原真实温度日期差分布。
+## 数值处理、质量筛选与格式
+- HLS服务器端执行`band × 10000 → int16`，检查每波段超出`[-500,15000]`或六波段全零的比例；超过1%丢弃patch。Fmask bits 0–3并集比例超过20%也丢弃。之后**将保存的反射率整数裁剪到`[0,10000]`**。旧样本检查的0/10000边界与此相容；当前读取器“不额外clip”并不否认上游已clip。
+- LST服务器端执行`(ST_B10 × 0.00341802 + 149.0 − 273.15) × 100 → int16`，返回后除以100得到摄氏度。超出`[-50,70]°C`置NaN；tile有效比例低于1%返回无数据；patch缺失超过1%不��存。最终NaN经过填充和整数裁剪，编码为`-32767`，有效温度按摄氏度×100保存。该流程支持既有[单位核验](../experiments/data/LST_ENCODING_VERIFICATION.md)的解释，不需重新套原始DN缩放。
+- `QA_PIXEL`在当前代码中单独请求，可失败；未额外依据QA bit位过滤LST。内置产品掩码、数值范围筛选、QA位过滤是不同机制，不能混称为完整云质量保证。
+- 当前代码可写五个文件（含可选`qa_pixel.npy`），但本项目冻结包只记录`bands.npy/fmask.npy/lst.npy/metadata.json`四文件。不能把新代码的可选字段追加宣称为旧包的已交付字段；不得改变现有冻结schema或mask来伪造一致性。
+## Tile选择、split及实际样本成员
+[`select_tiles()`](provenance/hlp_download_20260913/select_tiles.py)先按每个土地覆盖类别的占比top-500抽至多100个tile，再加城市占比top-1000、高Shannon熵top-1000，补充尚未覆盖且候选tile不少于3个的生态区，剔除指定极地区域。之后按dominant LULC分组：每组shuffle，源val数量为`max(1,int(n_class×0.05))`，其余为train。入口默认seed为42；它不是逐patch全局随机95/5划分。
+本项目已确定把源val解释为**测试**，无独立validation。同tile内全部记录继承split。算法现已可说明，但缺原`selected_tiles.csv`及其哈希与冻结成员的逐条复核。固定seed也不保证在改变集合迭代顺序、候选数据或代码版本后得到相同成员；优先发布现有冻结清单。
+Phase 3每tile最多预留92个patch、同一`(tile,row,col)`最多10条记录；预留后仍可能因LST检查失败而不落盘。待处理观测先shuffle，并发执行及限额会影响实际保留记录；不是保证各年份均匀的采样。
+[`finalize.py`](provenance/hlp_download_20260913/finalize.py)另提供同tile行列位置排重，以及训练中海洋/沙漠约10%保留，输出`train_samples.json/val_samples.json/manifest.json`，**不会删除原始patch目录**。当前冻结输入来自完整下载记录，保留的`download_progress.json`总数也为242,416；没有证据证明其采用Phase 4的子集清单。因此该阶段应列为“代码提供的后处理”，而非当前数据已经应用的筛选。它的同tile位置排重也不等于相邻tile footprint无交叠。
+## 尚需保留的来源边界
+已解决：第一套的产品collection、波段、温度公式、上游反射率裁剪、时间检索/mosaic机制、共用导出网格与分层split算法。
+尚未解决：全部历史导出的精确代码版本、原选择/观测CSV与最终清单、实际LST贡献scene ID与采集时间、逐patch地理变换，以及独立的全量配准/QA验证。此处代码仅对应HLP，不能据此替代HLC的原始导出实现。

data_inspection/dataset_documentation_audit.json ADDED Viewed

	@@ -0,0 +1,133 @@

+{
+  "scope": "All currently retained HLC manifest records; NPZ schema inspected on one bundle only",
+  "bundles": 277808,
+  "usable_month_pairs": 2892007,
+  "used_tile_variant_months": 28027,
+  "fine_collection_membership_samples_nonexclusive": {
+    "LANDSAT/LC08/C02/T1_L2": 1576097,
+    "LANDSAT/LC09/C02/T1_L2": 1325461
+  },
+  "same_day_modis_id_mismatches": 0,
+  "multi_scene_fine_samples": 2877831,
+  "grid_pixel_steps_m": [
+    [
+      30.0,
+      -30.0
+    ]
+  ],
+  "modis_resampling": {
+    "nearest": 2892007
+  },
+  "hls_collection_counts": {
+    "NASA/HLS/HLSL30/v002": 277808
+  },
+  "schema_example_sequence_id": "T01WCP_v000_p0000",
+  "schema_example": {
+    "temperature": {
+      "hr_lst": {
+        "shape": [
+          12,
+          256,
+          256
+        ],
+        "dtype": "int16"
+      },
+      "hr_valid": {
+        "shape": [
+          12,
+          256,
+          256
+        ],
+        "dtype": "uint8"
+      },
+      "lr_lst": {
+        "shape": [
+          12,
+          8,
+          8
+        ],
+        "dtype": "int16"
+      },
+      "lr_valid": {
+        "shape": [
+          12,
+          8,
+          8
+        ],
+        "dtype": "uint8"
+      },
+      "hr_st_qa_k_x10": {
+        "shape": [
+          12,
+          256,
+          256
+        ],
+        "dtype": "uint8"
+      },
+      "hr_flags": {
+        "shape": [
+          12,
+          256,
+          256
+        ],
+        "dtype": "uint8"
+      },
+      "lr_qc_day": {
+        "shape": [
+          12,
+          8,
+          8
+        ],
+        "dtype": "int16"
+      },
+      "lr_view_angle_deg": {
+        "shape": [
+          12,
+          8,
+          8
+        ],
+        "dtype": "int16"
+      },
+      "lr_view_time_h_x10": {
+        "shape": [
+          12,
+          8,
+          8
+        ],
+        "dtype": "int16"
+      }
+    },
+    "optical": {
+      "hls_reflectance_i16": {
+        "shape": [
+          6,
+          256,
+          256
+        ],
+        "dtype": "int16"
+      },
+      "hls_valid": {
+        "shape": [
+          256,
+          256
+        ],
+        "dtype": "uint8"
+      },
+      "hls_fmask": {
+        "shape": [
+          256,
+          256
+        ],
+        "dtype": "uint8"
+      },
+      "source_time_s": {
+        "shape": [],
+        "dtype": "int64"
+      },
+      "candidate_rank": {
+        "shape": [],
+        "dtype": "uint8"
+      }
+    }
+  }
+}

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/README.md ADDED Viewed

	@@ -0,0 +1,11 @@

+# Dataset split protocol
+Seed: 20260905. Select 118 of 2367 original-train MGRS tiles (approximately 5%) using SHA256(seed:tile) ranking. All sequences and months from a selected tile belong to val. Existing test membership stays fixed.
+| Split | Sequences | MGRS tiles | Usable months |
+|---|---:|---:|---:|
+| train | 250,449 | 2,249 | 2,608,772 |
+| val | 13,694 | 118 | 141,711 |
+| test | 13,665 | 123 | 141,524 |
+The three manifests contain the current split labels. Membership lists and hashes are stored alongside this file. Use train for fitting, val for model selection, and test for final evaluation. Tile IDs are disjoint; neighboring-tile geographic footprint overlap has not been assessed.

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/split_summary.json ADDED Viewed

	@@ -0,0 +1,49 @@

+{
+  "date": "2026-09-05",
+  "method": "Rank sorted original-train MGRS tile IDs by SHA256(seed:tile); select first round(0.05*N).",
+  "seed": 20260905,
+  "target_train_tile_fraction": 0.05,
+  "eligible_train_tiles": 2367,
+  "selected_val_tiles": 118,
+  "counts": {
+    "test": {
+      "sequences": 13665,
+      "tiles": 123,
+      "usable_months": 141524
+    },
+    "train": {
+      "sequences": 250449,
+      "tiles": 2249,
+      "usable_months": 2608772
+    },
+    "val": {
+      "sequences": 13694,
+      "tiles": 118,
+      "usable_months": 141711
+    }
+  },
+  "test_membership_unchanged": true,
+  "all_non_split_csv_fields_unchanged": true,
+  "pairwise_tile_id_overlap": 0,
+  "spatial_footprint_overlap_checked": false,
+  "files": [
+    {
+      "file": "phase4_dataset_manifest.csv",
+      "renamed_rows": 13694,
+      "before_sha256": "61e26ac492f5346a4e02b406914d68464638fff3653d2018196714943cee4edb",
+      "after_sha256": "7110aca1ec7ef1d55b3098686e98139d9230577734d45863468a5622af0c253c"
+    },
+    {
+      "file": "phase3_tile_variant_months_merged.csv",
+      "renamed_rows": 1416,
+      "before_sha256": "23bdb789ec6e01644f9bf085ee67bef7e13b9ff3af64f5f9b0f1c28977fe4378",
+      "after_sha256": "ee7502975b378407110e966c947b63e83c1a7490f4d607461e1809f1cc415d08"
+    },
+    {
+      "file": "hls_l8_conditions_2019_2025_lc08/hls_condition_manifest.csv",
+      "renamed_rows": 13694,
+      "before_sha256": "79746b7df291944b12a5c0e924b08169c6613603de8d4d4c29e138c3184295e0",
+      "after_sha256": "08d8d48d45e592b7e27994bcbc8835c8d493f08cef1f1c851c2d553e602da946"
+    }
+  ]
+}

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/test_sequences.csv ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:93d3e3d70704823c7cec63357fc994f02dde376c26b9131d86b9d48f23d6697b
+size 392388

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/test_tiles.txt ADDED Viewed

	@@ -0,0 +1,123 @@

+T03WXN
+T04VFK
+T05WMQ
+T06VXQ
+T09UXU
+T10TGK
+T11UMB
+T12UYE
+T12VWR
+T12VXL
+T13RFM
+T13SCV
+T13TEE
+T13UFB
+T14QLF
+T14QPH
+T14TNL
+T14UNB
+T14VLR
+T15VUE
+T16SED
+T16SGJ
+T16UFE
+T16WFD
+T17MQN
+T17QRD
+T17SNU
+T18MYC
+T18NTG
+T18PZQ
+T18UXF
+T18VXN
+T19HBC
+T19UFA
+T20MNA
+T21JUN
+T21LZC
+T22KGV
+T22LHK
+T23KNU
+T23LRG
+T28PDV
+T29PQN
+T29SQA
+T30NZP
+T30PXU
+T30TTK
+T30TWL
+T30UVU
+T31NGH
+T31RGJ
+T31TGL
+T31UCU
+T31UFT
+T32QRF
+T32UPU
+T32VLL
+T33JZM
+T33PTN
+T34JCM
+T34QDE
+T34TDQ
+T34UED
+T35JPM
+T35SPD
+T35TKF
+T35TLK
+T36KXC
+T36MTT
+T37TDL
+T37VCC
+T37VCK
+T38KQA
+T38KQF
+T38NRN
+T38SMB
+T39UXA
+T40QCF
+T40RGQ
+T41VMC
+T42STJ
+T42UVA
+T42VUH
+T42VWP
+T43QDC
+T43RDK
+T43RGN
+T43VDF
+T43WEM
+T44NMP
+T44PLT
+T44QPF
+T44UPF
+T45RTJ
+T45RXJ
+T45VUJ
+T46QEK
+T46RFU
+T47NQE
+T47QRV
+T47VPG
+T48QXJ
+T48UVD
+T49QGG
+T49RFP
+T49VEH
+T50HNG
+T50RLR
+T50SMH
+T50SPD
+T52KCB
+T52KGD
+T52SBH
+T52SFC
+T52TCP
+T52TGR
+T54SUE
+T54TVK
+T55GDN
+T55JCF
+T55MDP
+T55WFN
+T60HUD

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/train_sequences.csv ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:b07650b7a25d62fa02ad0a6ca8c9fde5c192a906d7ddce0d9e1a15b38fe534f3
+size 7202102

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/train_tiles.txt ADDED Viewed

	@@ -0,0 +1,2249 @@

+T01WCP
+T01WCQ
+T01WEQ
+T01WER
+T03VWJ
+T03VXK
+T03WXM
+T03WXQ
+T03WXT
+T04VCL
+T04VCP
+T04VCQ
+T04VDL
+T04VDN
+T04VDP
+T04VEL
+T04VEM
+T04WDB
+T04WDS
+T04WDU
+T04WDV
+T04WEV
+T05VMG
+T05VMH
+T05VMK
+T05VNJ
+T05VPH
+T05VPK
+T05VPL
+T05WPT
+T06VUN
+T06VUQ
+T06VUR
+T06VVP
+T06VWN
+T06VWP
+T06VWR
+T06VXN
+T06VXP
+T06VXR
+T06WVC
+T06WWB
+T06WXC
+T07VCH
+T07VCJ
+T07VCL
+T07VDH
+T07VDJ
+T07VDK
+T07VEJ
+T07VFF
+T07VFG
+T07VFH
+T07VFJ
+T07WFN
+T08VLM
+T08VLN
+T08VLP
+T08VMM
+T08VNK
+T08VPJ
+T08VPK
+T08VPR
+T08WMB
+T08WMS
+T08WNA
+T08WNB
+T08WNS
+T08WNT
+T08WNV
+T08WPA
+T08WPC
+T08WPV
+T09UVA
+T09UVB
+T09UWV
+T09UXS
+T09UYS
+T09UYT
+T09VUC
+T09VUD
+T09VUE
+T09VVC
+T09VVD
+T09VVK
+T09VWJ
+T09WVN
+T09WVP
+T09WVS
+T09WWN
+T09WWQ
+T09WWR
+T09WXR
+T10SEH
+T10SEJ
+T10SFF
+T10SFG
+T10SFH
+T10SGF
+T10SGG
+T10TEK
+T10TEP
+T10TEQ
+T10TES
+T10TET
+T10TFM
+T10TFP
+T10TGQ
+T10UCB
+T10UDA
+T10UDV
+T10UEG
+T10UEU
+T10UEV
+T10UGD
+T10UGE
+T10VCK
+T10VFR
+T10WDA
+T10WEA
+T10WEU
+T11RPP
+T11SKA
+T11SKB
+T11SKC
+T11SLA
+T11SLC
+T11SLU
+T11SLV
+T11SMT
+T11SNT
+T11SPA
+T11TLJ
+T11TLL
+T11TNL
+T11ULA
+T11ULU
+T11UMS
+T11UMT
+T11UPS
+T11UQV
+T11VLL
+T11VNH
+T11VPJ
+T11WMN
+T11WNM
+T11WNN
+T11WNS
+T11WNT
+T11WPP
+T11WPQ
+T11XNE
+T12QWM
+T12RUQ
+T12RVQ
+T12RWS
+T12RWT
+T12RXR
+T12RYP
+T12RZN
+T12STC
+T12SUB
+T12SVB
+T12SVF
+T12SVG
+T12SVJ
+T12SWA
+T12SWJ
+T12SXG
+T12SXJ
+T12SYA
+T12SYG
+T12SYJ
+T12TUL
+T12TUP
+T12TVK
+T12TVL
+T12TVM
+T12TVQ
+T12UUC
+T12UUE
+T12UVB
+T12UYU
+T12VUR
+T12VVK
+T12VVR
+T12VWK
+T12VXM
+T12VXP
+T12WVC
+T12WWE
+T12WWT
+T12WXD
+T12WXT
+T12XVJ
+T12XWJ
+T13QDE
+T13QGE
+T13QHC
+T13QHD
+T13RBH
+T13RCK
+T13RCL
+T13RDH
+T13RDJ
+T13RDK
+T13RDN
+T13RFH
+T13RFL
+T13RFN
+T13RGJ
+T13RGK
+T13RGL
+T13RGN
+T13SBD
+T13SCU
+T13SDV
+T13SED
+T13SER
+T13TCG
+T13TDE
+T13TDK
+T13TEL
+T13UGU
+T13UGV
+T13VCF
+T13VCH
+T13VCJ
+T13VDD
+T13VDE
+T13VDF
+T13VEF
+T13VEG
+T13VEH
+T13VEK
+T13VFC
+T13VFF
+T13VFG
+T13WDN
+T13WFN
+T13WFP
+T13XFA
+T14QKH
+T14QKJ
+T14QKK
+T14QLH
+T14QMG
+T14QMJ
+T14QNG
+T14QNH
+T14QNJ
+T14QNM
+T14QPG
+T14QQF
+T14QQG
+T14QRF
+T14RKP
+T14RKS
+T14RLP
+T14RLQ
+T14RMQ
+T14RMT
+T14RNT
+T14RNV
+T14RPP
+T14RPR
+T14RPU
+T14RPV
+T14SMA
+T14SPB
+T14SPE
+T14SQB
+T14SQF
+T14TKM
+T14TPN
+T14ULE
+T14UMC
+T14UME
+T14UNC
+T14UPF
+T14UQV
+T14VLL
+T14VLN
+T14VMM
+T14VMQ
+T14VNM
+T14VNR
+T14VPL
+T14VPR
+T14WMU
+T14WMV
+T14WNS
+T14WNU
+T14WNV
+T14WPT
+T14WPU
+T14WPV
+T14XMG
+T15PYS
+T15PZS
+T15QTA
+T15QUV
+T15QWV
+T15RTN
+T15RTP
+T15RWP
+T15RXP
+T15STA
+T15SUV
+T15SYC
+T15SYD
+T15SYU
+T15SYV
+T15TTF
+T15TUG
+T15TUH
+T15TUK
+T15TVG
+T15TVK
+T15TVL
+T15TYE
+T15TYF
+T15TYM
+T15UUQ
+T15UUR
+T15UVQ
+T15UVR
+T15UXS
+T15UYP
+T15VUF
+T15VVD
+T15VVE
+T15VVL
+T15VXC
+T15WVM
+T15WVR
+T15WXR
+T15XWE
+T16PBB
+T16PEU
+T16PEV
+T16PFT
+T16PGA
+T16PGS
+T16PGT
+T16PGU
+T16PHA
+T16PHB
+T16QCF
+T16QCJ
+T16SBD
+T16SBH
+T16SBJ
+T16SDJ
+T16SEB
+T16SEC
+T16SEE
+T16SEF
+T16SEJ
+T16SFD
+T16SFG
+T16SFH
+T16SFJ
+T16SGC
+T16TBL
+T16TCM
+T16TCN
+T16TCP
+T16TDL
+T16TDM
+T16TDN
+T16TDQ
+T16TDT
+T16TEK
+T16TEM
+T16TEP
+T16TFN
+T16TGK
+T16TGM
+T16TGN
+T16TGP
+T16UCA
+T16UEF
+T16UFC
+T16UFF
+T16UFU
+T16UGB
+T16UGC
+T16XEG
+T17MNU
+T17MPP
+T17MPS
+T17MPT
+T17MPU
+T17MRN
+T17MRU
+T17NRJ
+T17PNK
+T17QPE
+T17RLL
+T17RLM
+T17RLN
+T17RMK
+T17RML
+T17RMM
+T17RMN
+T17RNK
+T17RNL
+T17SKT
+T17SLU
+T17SMR
+T17SMT
+T17SPU
+T17SPV
+T17SQD
+T17SQV
+T17TKE
+T17TKG
+T17TLG
+T17TLH
+T17TLJ
+T17TMF
+T17TMG
+T17TMH
+T17TMJ
+T17TNE
+T17TNF
+T17TNH
+T17TNJ
+T17TPE
+T17TPH
+T17TPJ
+T17TQH
+T17ULS
+T17ULT
+T17ULU
+T17UNS
+T17UPA
+T17UQT
+T17UQU
+T17UQV
+T17WMU
+T17WMV
+T17WPT
+T17XMD
+T17XMF
+T17XMG
+T17XNG
+T18FWJ
+T18FWM
+T18FXG
+T18FXH
+T18FXJ
+T18FXK
+T18FXM
+T18GWP
+T18GXN
+T18GYR
+T18GYS
+T18GYU
+T18HXC
+T18HYF
+T18LVM
+T18LXN
+T18LZK
+T18LZN
+T18MUB
+T18MVC
+T18MWC
+T18MYU
+T18MYV
+T18MZC
+T18MZS
+T18MZT
+T18NTH
+T18NUG
+T18NUH
+T18NUJ
+T18NUN
+T18NVJ
+T18NVK
+T18NVL
+T18NXJ
+T18NYM
+T18NYN
+T18NZL
+T18PTQ
+T18PVR
+T18PWR
+T18PWS
+T18PYT
+T18QTJ
+T18QUH
+T18QVH
+T18QYG
+T18QZF
+T18QZG
+T18STG
+T18STH
+T18STJ
+T18SUF
+T18TUK
+T18TUQ
+T18TVK
+T18TVL
+T18TWK
+T18TWL
+T18TWR
+T18TXM
+T18TYM
+T18TYN
+T18UUC
+T18UUD
+T18UUE
+T18UUF
+T18UVD
+T18UVF
+T18UVG
+T18UWB
+T18UWC
+T18UWD
+T18UWE
+T18UWF
+T18UXD
+T18UXE
+T18UYB
+T18UYD
+T18UYE
+T18VUM
+T18VVH
+T18VVK
+T18VWH
+T18VWN
+T18VWP
+T18VXH
+T18VXM
+T18WVD
+T18WVS
+T18WWB
+T18WWC
+T18WWD
+T18WWE
+T18WWS
+T18WXD
+T18WXU
+T18WXV
+T18XVF
+T19GER
+T19GFN
+T19GGP
+T19HBB
+T19HBD
+T19HCB
+T19HCC
+T19HCD
+T19HCS
+T19HCT
+T19HDA
+T19HDS
+T19HEV
+T19HFB
+T19JHN
+T19KDR
+T19KFP
+T19KFR
+T19KGA
+T19LBE
+T19LBH
+T19LBJ
+T19LFG
+T19LGC
+T19LHC
+T19LHF
+T19LHL
+T19MBV
+T19MCQ
+T19MCU
+T19MET
+T19MFR
+T19MFV
+T19MGR
+T19MHN
+T19MHQ
+T19MHR
+T19NCJ
+T19NDB
+T19NDD
+T19PBN
+T19PDN
+T19PGM
+T19QBB
+T19QCB
+T19TBG
+T19TCH
+T19TFM
+T19TGL
+T19UCB
+T19UCU
+T19UDV
+T19UEV
+T19UFB
+T19UGV
+T19VCC
+T19VCF
+T19VCG
+T19VDC
+T19VDF
+T19VDK
+T19VEE
+T19VFD
+T19VFL
+T19WDM
+T19WDN
+T19WDQ
+T19WDR
+T19WDT
+T20GKU
+T20HMF
+T20HNG
+T20HNK
+T20HQJ
+T20JKQ
+T20JKR
+T20JKT
+T20JLQ
+T20JLR
+T20JMM
+T20JMQ
+T20JMT
+T20JQL
+T20JQM
+T20JQQ
+T20JQR
+T20KMU
+T20KND
+T20KQA
+T20LKR
+T20LLN
+T20MKS
+T20MKT
+T20MLA
+T20NKG
+T20NKL
+T20NMJ
+T20NNK
+T20PMR
+T20PMS
+T20ULD
+T20ULE
+T20UMF
+T20UNG
+T20UQB
+T20UQE
+T20VLH
+T20VNH
+T20XMN
+T21HUB
+T21JTF
+T21JTG
+T21JTH
+T21JTJ
+T21JTK
+T21JUL
+T21JVM
+T21JVN
+T21JWK
+T21JWN
+T21JXN
+T21KTA
+T21KVB
+T21KVP
+T21KVT
+T21KWP
+T21KZA
+T21KZB
+T21KZQ
+T21LXC
+T21LYD
+T21LZE
+T21MTP
+T21MTQ
+T21MTV
+T21MUQ
+T21MUV
+T21MXU
+T21MYU
+T21MZT
+T21NVB
+T21NXG
+T21NYD
+T21NYG
+T21NZA
+T21NZD
+T21UUA
+T21UUV
+T21UWP
+T21UWU
+T21UXQ
+T21WXV
+T22HCJ
+T22JCM
+T22JCT
+T22JEN
+T22JFS
+T22KBF
+T22KBG
+T22KCF
+T22KDC
+T22KFA
+T22KFV
+T22KGE
+T22KGG
+T22KHA
+T22KHE
+T22KHF
+T22KHG
+T22LBH
+T22LDM
+T22LEN
+T22LGH
+T22LGK
+T22LGM
+T22LHH
+T22LHJ
+T22MCA
+T22MHS
+T22WEU
+T22WEV
+T23KKA
+T23KKQ
+T23KKR
+T23KKS
+T23KKT
+T23KKV
+T23KLB
+T23KLQ
+T23KLR
+T23KLS
+T23KMQ
+T23KMS
+T23KNT
+T23KPT
+T23KPU
+T23LKC
+T23LKE
+T23LLF
+T23LLG
+T23LLL
+T23LMH
+T23LND
+T23LNG
+T23LPD
+T23LQJ
+T23MKM
+T23MLM
+T23MMM
+T23MNS
+T23MQM
+T23MQS
+T23MRS
+T23VMH
+T23VNJ
+T24KUD
+T24LTP
+T24LUP
+T24LVL
+T24LWM
+T24LXN
+T24LXR
+T24MTS
+T24MTT
+T24MUB
+T24MUU
+T24MUV
+T24MVA
+T24MXV
+T24VUR
+T24WXU
+T26WMB
+T26WMD
+T26WPC
+T26WPE
+T27WVU
+T27WVV
+T28PCV
+T28PET
+T28PFB
+T28PFU
+T28PGQ
+T28PGV
+T28PHR
+T28QCJ
+T28RFQ
+T29NQH
+T29NRH
+T29PKP
+T29PLN
+T29PML
+T29PMM
+T29PNL
+T29PQR
+T29PRK
+T29PRN
+T29QMB
+T29QPA
+T29QQB
+T29RMQ
+T29RNQ
+T29SNB
+T29SND
+T29SPB
+T29SPC
+T29SQC
+T29SQR
+T29TNG
+T29TNH
+T29TPE
+T29TPG
+T29TQE
+T29TQH
+T29UPA
+T29UPV
+T30NXN
+T30NXP
+T30NYN
+T30NYP
+T30NZN
+T30PTV
+T30PVR
+T30PWQ
+T30QVD
+T30QWF
+T30QWK
+T30QXE
+T30QXG
+T30RTN
+T30RUR
+T30RWP
+T30RXR
+T30STB
+T30STF
+T30SUD
+T30SUJ
+T30SVD
+T30SVG
+T30SWD
+T30SWG
+T30SWH
+T30SXD
+T30SXH
+T30SXJ
+T30TUK
+T30TUN
+T30TVK
+T30TVL
+T30TVN
+T30TWM
+T30TWN
+T30TXK
+T30TXP
+T30TXS
+T30TXT
+T30TYL
+T30TYQ
+T30TYR
+T30TYS
+T30TYT
+T30UUF
+T30UVG
+T30UWB
+T30UWC
+T30UWD
+T30UWE
+T30UWF
+T30UWU
+T30UXC
+T30UXD
+T30UXF
+T30UXU
+T30UXV
+T30UYB
+T30UYC
+T30UYV
+T30VVH
+T31NCH
+T31NDH
+T31NEH
+T31NEJ
+T31NFJ
+T31PBL
+T31PCM
+T31PDK
+T31PDL
+T31PEK
+T31PHP
+T31RDJ
+T31RDP
+T31REM
+T31RFM
+T31RGP
+T31SEU
+T31SGA
+T31SGV
+T31TBF
+T31TCG
+T31TCJ
+T31TCN
+T31TDG
+T31TDH
+T31TDJ
+T31TEJ
+T31TEL
+T31TFJ
+T31TFK
+T31TFL
+T31TFM
+T31TFN
+T31TGK
+T31TGM
+T31TGN
+T31UCQ
+T31UCT
+T31UDP
+T31UDQ
+T31UDR
+T31UEP
+T31UEQ
+T31UER
+T31UES
+T31UFQ
+T31UFR
+T31UFS
+T31UGP
+T31UGQ
+T31UGR
+T31UGS
+T31UGT
+T31UGU
+T32NKM
+T32NKN
+T32NLM
+T32NLN
+T32NPM
+T32PKU
+T32PLA
+T32PLQ
+T32PLR
+T32PLU
+T32PMR
+T32PMU
+T32PMV
+T32PNR
+T32PNS
+T32PNT
+T32PRA
+T32QPD
+T32QPL
+T32RQQ
+T32RQV
+T32SKF
+T32SLF
+T32SMJ
+T32SND
+T32SNF
+T32TLR
+T32TLS
+T32TLT
+T32TMQ
+T32TMR
+T32TMS
+T32TMT
+T32TNR
+T32TNT
+T32TPN
+T32TPP
+T32TPQ
+T32TQN
+T32TQP
+T32TQR
+T32TQS
+T32ULA
+T32ULB
+T32ULC
+T32ULD
+T32ULU
+T32ULV
+T32UMA
+T32UMB
+T32UMC
+T32UMD
+T32UMU
+T32UNA
+T32UNB
+T32UNC
+T32UND
+T32UNE
+T32UNF
+T32UNG
+T32UNU
+T32UNV
+T32UPA
+T32UPC
+T32UPD
+T32UPV
+T32UQA
+T32UQC
+T32UQD
+T32UQU
+T32UQV
+T32VLM
+T32VLP
+T32VMQ
+T32VNR
+T32VPR
+T32WPS
+T33JWN
+T33JXL
+T33JXM
+T33JYH
+T33JYJ
+T33KUV
+T33KVQ
+T33KVU
+T33KWT
+T33KWU
+T33KYB
+T33KYR
+T33KYS
+T33KZA
+T33KZP
+T33KZV
+T33LTE
+T33LUK
+T33LUL
+T33LVC
+T33LVG
+T33LWD
+T33LWG
+T33LWH
+T33LWK
+T33LXF
+T33LXH
+T33LYG
+T33MTP
+T33MUV
+T33NTH
+T33NUJ
+T33NVH
+T33NWH
+T33NXB
+T33PUN
+T33PUR
+T33PVM
+T33PVN
+T33PXK
+T33PYR
+T33QVB
+T33QZE
+T33QZF
+T33RUM
+T33SVB
+T33SWC
+T33TUG
+T33TUL
+T33TUM
+T33TVG
+T33TWF
+T33TWL
+T33TWN
+T33TXJ
+T33TXM
+T33TXN
+T33TYL
+T33TYM
+T33TYN
+T33UUP
+T33UUQ
+T33UUR
+T33UUS
+T33UUT
+T33UUU
+T33UVP
+T33UVQ
+T33UVR
+T33UVS
+T33UVT
+T33UVU
+T33UVV
+T33UWP
+T33UWQ
+T33UWR
+T33UWS
+T33UWT
+T33UXP
+T33UXQ
+T33UXR
+T33UXS
+T33UXT
+T33UXU
+T33UYP
+T33UYQ
+T33UYR
+T33UYS
+T33UYT
+T33UYU
+T33VUL
+T33VVF
+T33WVP
+T33WWR
+T33XVF
+T34HFH
+T34HGH
+T34JBP
+T34JDL
+T34JFL
+T34JFR
+T34JGT
+T34JHS
+T34KCC
+T34KEB
+T34KFB
+T34KFE
+T34KHC
+T34KHV
+T34LEN
+T34LFL
+T34MCE
+T34MCU
+T34MDC
+T34MEE
+T34NCP
+T34NEG
+T34NFF
+T34NHN
+T34PBA
+T34PFQ
+T34PHR
+T34QDJ
+T34QEE
+T34QFE
+T34RGQ
+T34SEJ
+T34SFG
+T34TCR
+T34TCT
+T34TDK
+T34TDL
+T34TDM
+T34TDR
+T34TDS
+T34TDT
+T34TEK
+T34TEL
+T34TEM
+T34TEN
+T34TES
+T34TET
+T34TFL
+T34TGP
+T34TGQ
+T34UCA
+T34UCB
+T34UCC
+T34UCD
+T34UDA
+T34UDU
+T34UEA
+T34UEB
+T34UEC
+T34UEV
+T34UFA
+T34UGA
+T34UGV
+T34WEA
+T35HKC
+T35HLD
+T35HPE
+T35JKM
+T35JNL
+T35JNM
+T35JPL
+T35KKA
+T35KKB
+T35KMU
+T35KNQ
+T35KPP
+T35KQQ
+T35KRA
+T35LKD
+T35LMC
+T35LMD
+T35LMJ
+T35LNC
+T35LPE
+T35LPL
+T35LQE
+T35LQL
+T35LRH
+T35LRL
+T35MLN
+T35MMM
+T35MNV
+T35MQS
+T35MQT
+T35MQU
+T35MQV
+T35MRM
+T35MRV
+T35NKD
+T35NKH
+T35NLB
+T35NLC
+T35NNB
+T35NPA
+T35NQF
+T35NQG
+T35NQH
+T35NRA
+T35NRB
+T35PKQ
+T35PRL
+T35QPD
+T35RKJ
+T35RKL
+T35RMJ
+T35RPH
+T35SMD
+T35SNB
+T35SNC
+T35SND
+T35SPB
+T35SPC
+T35SQA
+T35SQB
+T35SQC
+T35SQD
+T35TLJ
+T35TMG
+T35TMJ
+T35TMK
+T35TMM
+T35TMN
+T35TNE
+T35TNL
+T35TNN
+T35TPM
+T35TPN
+T35TQE
+T35TQM
+T35ULA
+T35ULQ
+T35UMP
+T35UMQ
+T35UMT
+T35UNP
+T35UNQ
+T35UNV
+T35UPQ
+T35UPR
+T35UQR
+T35UQS
+T35VPG
+T35VPK
+T36JTT
+T36JUP
+T36JUR
+T36JUS
+T36JUT
+T36JVR
+T36KTF
+T36KTG
+T36KUV
+T36KVC
+T36KVD
+T36KWU
+T36KXB
+T36KXE
+T36LVP
+T36LWK
+T36LXM
+T36LXR
+T36LYK
+T36LZH
+T36LZJ
+T36LZK
+T36LZN
+T36LZR
+T36MTC
+T36MTD
+T36MTV
+T36MUC
+T36MUE
+T36MUT
+T36MUV
+T36MVA
+T36MWB
+T36MWC
+T36MXS
+T36MXV
+T36MZA
+T36MZB
+T36MZC
+T36MZT
+T36NTF
+T36NTG
+T36NTH
+T36NUF
+T36NUH
+T36NUK
+T36NVF
+T36NVG
+T36NXG
+T36NZN
+T36PVC
+T36PXQ
+T36PXS
+T36PYS
+T36QUD
+T36QUH
+T36QYH
+T36QZG
+T36QZJ
+T36RTT
+T36RTU
+T36RTV
+T36RUU
+T36RUV
+T36RXN
+T36STG
+T36STH
+T36STJ
+T36SUG
+T36SVF
+T36SVG
+T36SXG
+T36SYA
+T36SYB
+T36SYG
+T36TTK
+T36TUK
+T36TUS
+T36TVK
+T36TWT
+T36TXT
+T36TYL
+T36UUA
+T36UUB
+T36UWU
+T36UWV
+T36UXG
+T36UXU
+T36UYA
+T36UYD
+T36VUM
+T36VVH
+T36VXN
+T36WVB
+T36WWA
+T36WWT
+T37KBA
+T37LBF
+T37LCD
+T37LED
+T37LEE
+T37LEH
+T37LFE
+T37MBT
+T37MBV
+T37MCR
+T37MCS
+T37MCU
+T37MFT
+T37NCH
+T37NDE
+T37NDF
+T37NEB
+T37NEF
+T37NFE
+T37NFF
+T37NGA
+T37NHB
+T37NHH
+T37PGP
+T37PHK
+T37PHQ
+T37QED
+T37RFK
+T37SBB
+T37SBS
+T37SBU
+T37SCA
+T37SCB
+T37SCV
+T37SDA
+T37SEA
+T37TBF
+T37TDK
+T37TEK
+T37TEL
+T37TEN
+T37TGH
+T37TGK
+T37UCA
+T37UCB
+T37UCP
+T37UCR
+T37UCS
+T37UDA
+T37UDP
+T37UDV
+T37UEA
+T37UEB
+T37UEP
+T37UET
+T37UEU
+T37UEV
+T37UGT
+T37UGU
+T37VDC
+T37WDQ
+T37WEQ
+T38JPT
+T38KLA
+T38KLV
+T38KMC
+T38KMG
+T38KNA
+T38KNB
+T38KPG
+T38KQB
+T38KQC
+T38KQE
+T38LPH
+T38LQH
+T38NKM
+T38NLJ
+T38NMK
+T38NMM
+T38NMP
+T38NQK
+T38NQM
+T38NQN
+T38PLA
+T38PMB
+T38PMR
+T38PNA
+T38PPA
+T38QLE
+T38RKQ
+T38RLQ
+T38RPN
+T38RPV
+T38RQN
+T38RQT
+T38SLH
+T38SMC
+T38TLP
+T38TMK
+T38TMN
+T38TMS
+T38TPS
+T38TQL
+T38TQM
+T38TQR
+T38ULF
+T38UMD
+T38UNC
+T38UPA
+T38UQE
+T38UQU
+T38WPU
+T39KTU
+T39LUE
+T39LUF
+T39QVD
+T39RUK
+T39RWN
+T39SUB
+T39SUD
+T39SWS
+T39SWV
+T39SXA
+T39SYA
+T39TTF
+T39TTG
+T39TUE
+T39TUF
+T39TVE
+T39TVN
+T39TXL
+T39TXM
+T39UUB
+T39UUV
+T39UVP
+T39UVV
+T39UWP
+T39UXQ
+T39UYQ
+T39UYR
+T39VUC
+T39WXQ
+T39XWA
+T39XWB
+T40QCJ
+T40QCM
+T40QDM
+T40QFK
+T40QFL
+T40QGK
+T40RCP
+T40RFV
+T40SBF
+T40SCF
+T40SEH
+T40SFG
+T40SFH
+T40SGF
+T40TFR
+T40TFT
+T40UCE
+T40UCV
+T40UDF
+T40UFU
+T40UGA
+T40UGV
+T40VDK
+T40VDQ
+T40WEA
+T40WEU
+T40XDG
+T41RMN
+T41RNJ
+T41TLE
+T41TPE
+T41TQE
+T41TQF
+T41TQJ
+T41ULB
+T41ULQ
+T41ULR
+T41UMA
+T41UMB
+T41UNQ
+T41UNR
+T41UPB
+T41UQV
+T41VLD
+T41VMG
+T41VNC
+T41VPJ
+T41WNN
+T41WNP
+T42QVM
+T42QYK
+T42QZL
+T42RUN
+T42RYT
+T42RYU
+T42SUJ
+T42SVH
+T42SWC
+T42SXB
+T42SXC
+T42SXD
+T42SXE
+T42SYC
+T42SYD
+T42SYJ
+T42TTK
+T42TUK
+T42TVL
+T42TWK
+T42TWL
+T42TWM
+T42TXK
+T42TXL
+T42TXP
+T42TXQ
+T42TXR
+T42TYK
+T42TYL
+T42TYT
+T42UUD
+T42UUE
+T42UVG
+T42UVV
+T42UWG
+T42UXF
+T42UXG
+T42UXV
+T42UYD
+T42VUK
+T42VUN
+T42VVH
+T42VVN
+T42VWH
+T42VWJ
+T42VWQ
+T42VXJ
+T42VXP
+T42WVT
+T42WWC
+T42WWU
+T42WXT
+T42WXU
+T42XWF
+T43PEN
+T43PFM
+T43PFR
+T43PGK
+T43PGN
+T43PGQ
+T43PHN
+T43QBF
+T43QCB
+T43QCF
+T43QCV
+T43QDD
+T43QDU
+T43QEB
+T43QEF
+T43QEG
+T43QGC
+T43QGU
+T43QHA
+T43RBP
+T43RCQ
+T43RDP
+T43RDQ
+T43REH
+T43REM
+T43REN
+T43REP
+T43REQ
+T43RFM
+T43RFN
+T43RFP
+T43RFQ
+T43RGL
+T43RGM
+T43RGP
+T43RHH
+T43RHJ
+T43SBA
+T43SBB
+T43SBT
+T43SBU
+T43SCS
+T43SDR
+T43SDS
+T43SDU
+T43SET
+T43SFR
+T43SGR
+T43TBE
+T43TBF
+T43TCF
+T43TDH
+T43TFH
+T43TFJ
+T43UCB
+T43UDT
+T43UEB
+T43UEQ
+T43UET
+T43UFB
+T43VCC
+T43VCD
+T43VCE
+T43VCH
+T43VCJ
+T43VDG
+T43VEC
+T43VFH
+T44NMN
+T44NNN
+T44PKS
+T44PLU
+T44QKE
+T44QKF
+T44QKH
+T44QMD
+T44QND
+T44QNJ
+T44QPG
+T44QPK
+T44RKR
+T44RLN
+T44RLS
+T44RMP
+T44RMU
+T44RPP
+T44RQS
+T44SKC
+T44SLE
+T44TPK
+T44TPN
+T44TQK
+T44TQP
+T44TQR
+T44ULV
+T44UMU
+T44UMV
+T44UNE
+T44UNF
+T44UNG
+T44UNV
+T44VLP
+T44VLQ
+T44VNH
+T44VNK
+T44VNN
+T44VNQ
+T44VPL
+T44VPQ
+T44WMV
+T45QTC
+T45QUC
+T45QVG
+T45QWE
+T45QWF
+T45QWG
+T45QXE
+T45QXF
+T45QXG
+T45QYF
+T45QYG
+T45QZF
+T45QZG
+T45RTM
+T45RUJ
+T45RUK
+T45RVJ
+T45RVK
+T45RWH
+T45RXH
+T45RYH
+T45RYK
+T45SYT
+T45TWJ
+T45TXN
+T45UYS
+T45UYT
+T45VUE
+T45VUF
+T45VUH
+T45WVQ
+T45WWQ
+T45WWR
+T45WWS
+T45WWV
+T46QBL
+T46QCL
+T46QCM
+T46QDK
+T46QEM
+T46QFF
+T46QGH
+T46QGJ
+T46QHD
+T46RBN
+T46RBS
+T46RCN
+T46RCQ
+T46RDQ
+T46RDR
+T46REP
+T46RFN
+T46RFP
+T46RFQ
+T46RGQ
+T46RGU
+T46SBC
+T46SCB
+T46SCF
+T46SGH
+T46TCT
+T46UCD
+T46UDE
+T46UEC
+T46WFE
+T46XDH
+T47NND
+T47NRD
+T47NRG
+T47PNR
+T47PNS
+T47PNT
+T47PPR
+T47PPS
+T47PPT
+T47PQQ
+T47PQR
+T47PRS
+T47PRT
+T47QMA
+T47QRU
+T47RKK
+T47RKN
+T47RLJ
+T47RLK
+T47RML
+T47RPJ
+T47RPK
+T47RQN
+T47RQP
+T47RRH
+T47SPB
+T47SPU
+T47SQC
+T47TMN
+T47TNN
+T47TQM
+T47ULS
+T47UNU
+T47WMV
+T47WNV
+T48MTA
+T48MVC
+T48MYT
+T48MZT
+T48PTB
+T48PTC
+T48PUB
+T48PUC
+T48PVB
+T48PWR
+T48PWS
+T48PWT
+T48PXB
+T48PXS
+T48PYB
+T48PYT
+T48PZC
+T48QTD
+T48QTE
+T48QWF
+T48QWG
+T48QWH
+T48QWJ
+T48QZL
+T48RTN
+T48RTQ
+T48RUN
+T48RUQ
+T48RUR
+T48RUT
+T48RUV
+T48RVU
+T48RWQ
+T48RXP
+T48RXR
+T48RXT
+T48RXU
+T48STC
+T48SUE
+T48SUF
+T48SVC
+T48SWC
+T48SXH
+T48SXJ
+T48SYD
+T48TYS
+T48UWC
+T48VUQ
+T48VVL
+T48VVM
+T48VXL
+T48VXM
+T48WXD
+T48XVG
+T48XVL
+T48XVM
+T48XXF
+T49JHN
+T49MCV
+T49MDM
+T49MEM
+T49MEN
+T49MEU
+T49MFM
+T49MHS
+T49PBQ
+T49QBF
+T49QCE
+T49QCF
+T49QCG
+T49QDE
+T49QDF
+T49QEE
+T49QEF
+T49QFE
+T49QFF
+T49QFG
+T49QGF
+T49QHF
+T49QHG
+T49RBM
+T49RDH
+T49REK
+T49REP
+T49RFJ
+T49RFK
+T49RFL
+T49RFM
+T49RFN
+T49RGJ
+T49RGK
+T49RGL
+T49RGM
+T49RGN
+T49RGP
+T49RGQ
+T49RHJ
+T49SBT
+T49SBU
+T49SCT
+T49SCU
+T49SDU
+T49SDV
+T49SEA
+T49SEB
+T49SER
+T49SEU
+T49SEV
+T49SFB
+T49SFD
+T49SFS
+T49SFT
+T49SFU
+T49SFV
+T49SGA
+T49SGC
+T49SGR
+T49SGS
+T49SGT
+T49SGU
+T49TCF
+T49TDE
+T49TDM
+T49TEF
+T49TEN
+T49TFE
+T49TFM
+T49UDT
+T49UEU
+T49VDF
+T49WEQ
+T49WFP
+T49XDE
+T49XEE
+T50HPJ
+T50HPK
+T50JKS
+T50JLL
+T50JLN
+T50JLQ
+T50JNP
+T50JPR
+T50JPS
+T50JQR
+T50KNB
+T50MKB
+T50NKK
+T50NLG
+T50NLH
+T50PRC
+T50QKL
+T50QKM
+T50QLM
+T50QML
+T50QMM
+T50QRL
+T50RKR
+T50RKU
+T50RKV
+T50RLS
+T50RLT
+T50RLU
+T50RMN
+T50RMR
+T50RMS
+T50RMT
+T50RMU
+T50RMV
+T50RNS
+T50RNT
+T50RNU
+T50RNV
+T50RPP
+T50RPS
+T50RPV
+T50RQT
+T50RQU
+T50RQV
+T50SKA
+T50SKB
+T50SKC
+T50SKD
+T50SKE
+T50SKF
+T50SKG
+T50SKH
+T50SLA
+T50SLB
+T50SLC
+T50SLD
+T50SLF
+T50SLG
+T50SLH
+T50SLJ
+T50SMA
+T50SMB
+T50SMC
+T50SMD
+T50SME
+T50SMF
+T50SMG
+T50SMJ
+T50SNA
+T50SNB
+T50SNC
+T50SND
+T50SNE
+T50SNF
+T50SNG
+T50SNH
+T50SNJ
+T50SPA
+T50SPB
+T50SPC
+T50SPE
+T50SPF
+T50SQA
+T50SQB
+T50SQC
+T50SQF
+T50TLK
+T50TLL
+T50TMK
+T50TPK
+T50TQL
+T50ULC
+T50ULV
+T50UNU
+T50UPB
+T50UPV
+T50WMB
+T51JUF
+T51JYL
+T51KXB
+T51KYR
+T51KYS
+T51KYU
+T51KZU
+T51NXJ
+T51NZJ
+T51PTS
+T51PTT
+T51PUR
+T51QTF
+T51QTG
+T51QTU
+T51RTM
+T51RTN
+T51RTP
+T51RTQ
+T51RUH
+T51RUN
+T51STA
+T51STB
+T51STR
+T51STS
+T51STT
+T51SUB
+T51SYD
+T51TTF
+T51TUF
+T51TUG
+T51TVE
+T51TVF
+T51TVG
+T51TVJ
+T51TWE
+T51TWF
+T51TWG
+T51TWH
+T51TWJ
+T51TWN
+T51TXE
+T51TXH
+T51TXJ
+T51TXK
+T51TXL
+T51TXM
+T51TYJ
+T51TYK
+T51TYL
+T51TYM
+T51TYN
+T51UUT
+T51UVU
+T51WXV
+T51XWA
+T51XWB
+T52JCL
+T52JGT
+T52JHS
+T52KBA
+T52KBD
+T52KCC
+T52KDC
+T52KHE
+T52LEH
+T52LHK
+T52SBE
+T52SBF
+T52SBJ
+T52SCE
+T52SCF
+T52SCG
+T52SCJ
+T52SDE
+T52SFA
+T52SFB
+T52TCQ
+T52TCR
+T52TCS
+T52TFT
+T52TGQ
+T52UDF
+T52UEV
+T52UGU
+T52XDF
+T53HNC
+T53HND
+T53HQD
+T53JLF
+T53JPH
+T53JPL
+T53KKB
+T53KPB
+T53KQS
+T53KRT
+T53LKG
+T53LME
+T53MKU
+T53MPR
+T53MPS
+T53SKU
+T53SLT
+T53SLU
+T53SMT
+T53SMU
+T53SNU
+T53SPA
+T53SPU
+T53SQA
+T53SQV
+T53TLK
+T53TLL
+T53TML
+T53TNL
+T53TNM
+T53UNR
+T53UPT
+T53VMF
+T53WNU
+T53WPU
+T54HUF
+T54HWK
+T54HXE
+T54HYK
+T54JVL
+T54JXL
+T54JZT
+T54KVA
+T54KVF
+T54KWB
+T54KWG
+T54KYA
+T54KYG
+T54KZG
+T54KZV
+T54LXR
+T54MTB
+T54MUS
+T54MVV
+T54MXB
+T54MXV
+T54MYT
+T54STD
+T54STE
+T54STF
+T54SUF
+T54SUG
+T54SVG
+T54SVH
+T54SVJ
+T54SWJ
+T54TWK
+T54TWN
+T54TXP
+T54UUE
+T54UVE
+T54UWD
+T54UXA
+T54VVK
+T54WWD
+T54WXA
+T55GCQ
+T55GDP
+T55GEQ
+T55HBU
+T55HCU
+T55KBU
+T55KCV
+T55KDR
+T55LGK
+T55MCN
+T55MCQ
+T55MHP
+T55VEG
+T55WDR
+T56HKH
+T56HLH
+T56MLV
+T56MMA
+T56MQT
+T56VMQ
+T56WMD
+T56WNA
+T56WNC
+T56WND
+T56WPA
+T57UXB
+T57VXC
+T57WWP
+T57WWR
+T57WWT
+T57WXR
+T58GGQ
+T58GGR
+T58WDB
+T59GLK
+T59GPP
+T59WNN
+T59WNT
+T60WVA

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/val_sequences.csv ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:722a8ceaf6fac3b620cf5abe33ffec2fe8674a3ac69683a62738e0149bb2e4ca
+size 393651

data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/splits/val_tiles.txt ADDED Viewed

	@@ -0,0 +1,118 @@

+T01WDR
+T08UPE
+T08VNL
+T08VNM
+T08WPT
+T12SVC
+T12VWQ
+T13QFC
+T13RDQ
+T13SDD
+T13VDH
+T14VLM
+T14VNL
+T15SUD
+T15TXG
+T16TEL
+T16UED
+T16UEU
+T16VCH
+T17MPN
+T17SNV
+T18GXP
+T18MVA
+T18SUE
+T18SVJ
+T18TVR
+T18UVC
+T19NDA
+T19UCV
+T20UPG
+T20VML
+T21JUK
+T22HCK
+T22KHV
+T22LGJ
+T22LGL
+T24MTB
+T29RMP
+T30NUN
+T30QUG
+T32SMF
+T32TPR
+T32UMV
+T32UPB
+T32UQB
+T33TUH
+T33TWE
+T33TWM
+T34KFF
+T34KHU
+T34MBA
+T34TCS
+T34UDC
+T34UEU
+T34UFU
+T35JQF
+T35KNB
+T35KPB
+T35LPK
+T35LQH
+T35MQR
+T35TNH
+T35TPE
+T36JUQ
+T36LYH
+T36LYQ
+T36NZK
+T36VWQ
+T37UDB
+T38KNC
+T38NQL
+T38SMG
+T38TPP
+T38TPQ
+T38TQQ
+T39UVT
+T40TGR
+T40UCU
+T42TVK
+T42VXH
+T43QCD
+T43RDN
+T44RMQ
+T44WMB
+T45RWJ
+T45RZH
+T46QBM
+T47NMD
+T47PQT
+T47QPU
+T47RNH
+T48PXT
+T48QUD
+T48RTR
+T48RUU
+T48RVV
+T48RWT
+T48RXQ
+T49REH
+T49SFA
+T49SFC
+T49SGB
+T50QLL
+T50RKP
+T50RNN
+T50RPT
+T50SLE
+T50TNK
+T50UQD
+T51KZB
+T51TYH
+T52JHT
+T53HME
+T53JPG
+T53SPV
+T54HWF
+T56WNB
+T59GPQ

eo_data/README.md ADDED Viewed

	@@ -0,0 +1,141 @@

+# 两套数据的统一入口
+名称与语义以[数据集文档](../data_inspection/FINAL_DATASET_SUMMARY.md)为准；[dataset_catalog.json](../experiments/data/dataset_catalog.json)提供机器可读映射。
+| 工作名称 | 兼容读取 ID | 文档划分 → API split |
+|---|---|---|
+| HLS-LST-Pairs（HLP）v2 | `prithvi` | train → `train`；validation → `val`；test → `test`；须指定新 prepared |
+| HLS-LST-CrossSensor（HLC） | `lstsr_tb` | train → `train`；validation → `val`；test → `test` |
+HLP/HLC 是文档名称，冻结 API 仍接收上表的旧 ID。`lst` / `lst_hr` 指 fine-resolution LST；HLC 原字段 `lr_*` 指 coarse-resolution LST。HLC 一条 `sequence_id` 对应月份集合（calendar-month bundle），月份可跨年，不能将其默认作为连续时间序列。Landsat fine LST 是卫星反演参考产品。现有入口返回单模态自重建样本，尚未封装 coarse LST＋HLS → fine LST 三元组。
+HLP 新版读取：`open_dataset("prithvi", "lst", "val", prepared="processed_data/hlp_split_v2_20260914")` 返回独立验证集；同一 prepared 下 `train/test` 分别读取新训练/固定测试。划分为218,975/11,684/11,757对，详见[划分协议](../data_inspection/hlp_split_20260914/README.md)。HLC 继续用 v1。下面未传 prepared 的旧调用示例只用于历史复现；冻结默认仍是 v1，旧 HLP `val` 表示测试。
++
++新 HLP 版本的归一化已排除验证成员的贡献，验证与测试共用新训练参数。旧模型见过新验证成员，不能作为独立验证模型直接沿用。
+两份数据独立使用；处理方法共用。当前版本是无人工噪声、无几何增强的自重建数据。
+## 一键处理与读取
+在项目根目录运行：
+```powershell
+.\prepare_data.ps1 -Workers 4
+python examples/read_eo_data.py
+```
+预处理命令会处理全量数据并验证结果。中断后重复执行同一命令可从已提交的 512 条记录检查点继续；已完成的数据保持冻结。输出位于 `processed_data/v1/`。开发子集有独立目录，默认训练接口拒绝使用。
+```python
+from eo_data import open_datasets, open_dataset
+data = open_datasets(split="train")
+hlp_hls = data["prithvi"]["hls"]
+hlp_lst = data["prithvi"]["lst"]
+hlc_hls = data["lstsr_tb"]["hls"]
+hlc_lst = data["lstsr_tb"]["lst"]
+sample = hlp_hls[0]
+x = sample["image"]                 # float32 [6,256,256]; LST 为 [1,256,256]
+y = sample["target"]                # 同值、独立内存
+valid = sample["reference_mask"]    # bool [1,256,256]，广播到全部通道
+decoded = hlp_hls.denormalize(x) # 仅在 valid 位置代表原数据
+fingerprint = hlp_hls.fingerprint  # 保存到实验配置/checkpoint
+validation = open_dataset("lstsr_tb", "lst", "val")
+```
+此接口按需读取，不会把整个数据集装入内存。使用其他位置时传 `root=项目根目录`；使用其他预处理版本时传 `prepared=该版本目录`（其下含 `prithvi/` 和 `lstsr_tb/`）。别名支持 `prithvi_data`、`lstsr_tb_final_upload_20260721`、`lst_hr`。
+`get_metadata(i)` 提供来源信息；这些信息不会自动输入模型。`epoch_indices(epoch, seed)` 产生可复现的样本排列。所有样本的 `corruption_mask` 当前为 false，`input_mask` 等于 `reference_mask`。
+## PyTorch 训练环境
+基础依赖见 `requirements.txt`。NumPy 接口无需 PyTorch；训练环境安装 PyTorch 后可直接调用：
+```python
+from eo_data import make_dataloader
+if __name__ == "__main__":  # Windows 多进程必须保留此保护
+    loader = make_dataloader("prithvi", "hls", "train",
+                             batch_size=16, num_workers=4, seed=20260909)
+    for batch in loader:
+        x, y = batch["image"], batch["target"]
+        mask = batch["reference_mask"].expand_as(y)
+        # prediction = model(x)
+        # loss = (((prediction-y).square() * mask).flatten(1).sum(1)
+        #         / mask.flatten(1).sum(1)).mean()
+```
+普通 VAE 与 Prithvi 架构 VAE 必须使用相同数据、seed、batch 配置和 mask 损失。Prithvi 如果要求时间维，只做 `x.unsqueeze(2)` 得到 `[B,C,1,H,W]`。训练脚本不要另加归一化、裁剪或尺寸变换。各 epoch 依次迭代同一个 loader；不要每个 epoch 重建并重置相同 generator。
+## 固定的数据约定
+- HLS 六波段顺序：Blue、Green、Red、NIR、SWIR1、SWIR2；原始整数乘 0.0001，读取器无额外 clipping。HLP 下载端已执行 clip(0,10000)，不能据读取器行为推定上游未裁剪。
+- HLS 排除源填充值、Fmask 255 与 bit1/2/3，HLC 还与已有 valid mask 取交集。零值、雪、水、气溶胶位不额外剔除。
+- LST 读取 fine-resolution 256×256。两来源均按“摄氏度 × 100”的 int16 存储编码解释，已用原始 Landsat 像元抽样核验并经用户确认，后续实验沿用此约定。恢复摄氏度为 `stored / 100.0`，不重复套用 Landsat 原始 DN 公式。
+- 四组统计只在各自 train 中拟合：先算每个样本有效像元均值/二阶矩，再对样本等权汇总；HLS 按波段，LST 单通道。val/test 复用 train 参数。
+- 无效像元在归一化后填 0，并保留 mask；全无效样本按模态排除，记录在 SQLite `rejected` 表。
+- HLP v2 为独立 train/val/test；旧v1源 train/val 分别表示训练池/测试；HLC 的 train/val/test 分别表示训练/验证/测试。两份数据不合并。HLC 的 HLS 每个月份集合（原键 `sequence_id`）只计一次，LST 仅展开 manifest 的可用月份，不补齐缺月。
+### LST 摄氏度读取约定
+当前 `image` / `target` 已做 z-score，`denormalize()` 返回存储编码值。因此恢复温度要先反归一化，再除以 100，并使用原始有效 mask：
+```python
+import numpy as np
+ds = open_dataset("prithvi", "lst", "train")  # lstsr_tb 使用同样方法
+sample = ds[0]
+temperature_c = ds.denormalize(sample["image"]) / 100.0
+temperature_c = np.where(sample["reference_mask"], temperature_c, np.nan)
+```
+存储值、训练均值和标准差同时除以 100，z-score 保持一致，因此现有训练输入无需重算。MAE/RMSE 若在反归一化后的存储单位中计算，除以 100 得到 °C；MSE 除以 10000。冻结 v1 文件里的未知单位标志是构建时的历史状态，以本约定及[单位核验记录](../experiments/data/LST_ENCODING_VERIFICATION.md)为当前解释。压缩包内的说明保留打包时版本，迁移时一并携带这份更新说明。
+## 存储与可恢复性
+HLP 的四个原始文件逐样本无损编码，512 个样本组成一个 `.eoz` 分片。每个样本独立解压，SQLite 提供字节偏移，可随机读取。编码使用整数差分、字节重排及 Zstandard；NPY 头和 JSON 原始字节均保留。写入后逐条从磁盘解压并核对原始 SHA-256，分片另存完整 SHA-256。
+HLC 复用已有压缩 NPZ，只新增固定索引、掩码有效像元计数和归一化参数；不复制大量 float32 数组。每个读取进程缓存最近两个源 NPZ。随机读取 LST 月份仍需解压所在的 12 个月份槽位的 fine LST 数组，这是保留现有压缩存储的代价。NPZ 大小和纳秒修改时间与预处理记录不符时拒绝训练；迁移这些源文件应保留修改时间。
+`bundle.json` 是完成状态与版本证据；只有完成全量扫描、统计、分片校验和索引冻结后才生成。`progress.json` 给出处理中状态。`normalization.json` 保存最终参数；`protocol.json` 是输入规范快照，其历史 status 字段不代表当前产物状态。`verification.json` 保存读取验收结果。
+```powershell
+python -m eo_data verify --dataset all --samples 32
+python -m eo_data restore-prithvi --destination D:\restored_prithvi
+```
+恢复目标必须为空；可加 `--limit 8` 验证小批恢复。恢复会写回四个原始文件及辅助文件，内容与原目录一致。恢复命令同时支持分片目录和下述单文件模式。HLC 仍依赖原 NPZ。
+## HLP 单文件压缩包
+当前交付文件为 `artifacts/prithvi_data_v1_20260909.zip`。它包含全部无损 EOZ 分片、冻结的索引和统计参数，以及读取代码。ZIP64 中的 EOZ 已经压缩，因此使用直接存储；读取器直接跳到样本的字节位置，无需解压整个 ZIP 或整个分片。
+在当前项目里，`processed_data/v1/prithvi/storage.json` 指向该 ZIP，原来的 `open_dataset` / `open_datasets` 调用完全相同。只需保留新 ZIP 与轻量索引目录；旧解压目录、旧 ZIP 和单独的 EOZ 分片可在新包验证后清理。
+迁移 ZIP 后，可用一条命令验证它并提取必需的索引（不提取大型分片）：
+```powershell
+python -m eo_data attach-prithvi D:\datasets\prithvi_data_v1_20260909.zip
+```
+迁移到没有代码的新项目时，先从 ZIP 中提取 `eo_data/` 文件夹并安装 `eo_data/requirements.txt`，再在该项目中运行上述命令。也可以完整解压整个 ZIP，直接使用其中的分片目录。ZIP 内容有逐文件 SHA-256 清单，外部 `.sha256` 文件给出整个 ZIP 的校验值。
+从已完成、仍保留分片的预处理目录生成并验证新包：
+```powershell
+python -m eo_data archive-prithvi --destination artifacts\prithvi_data_v1_20260909.zip
+```
+该命令不覆盖已有压缩包，也不会自行删除原始文件。当前项目的旧副本清理由用户单独授权执行。
+构建开始后不要修改 `eo_data/*.py` 或输入 `experiments/data/protocol.json`；恢复会检查代码和协议指纹。v1 的处理规则固定在 `core.py`，编辑协议文本不会自动改变算法。改变处理方法应同步实现代码并使用新输出版本，避免覆盖已用于实验的参数。读取器检查处理代码版本；同一输出目录的并发预处理会被写锁拒绝。
+## 验证
+```powershell
+python -m pytest tests/test_eo_data.py -q
+```
+测试覆盖整数极值无损恢复、压缩损坏检测、mask/零值规则、样本等权统计、两种源格式的 train-only 参数、月份展开、统一输出、pickle 重建、源文件变化检测、恢复原目录、事务断点续跑、并发写锁，以及删除松散分片后的 ZIP 直接读取与迁移。正式运行另对全部 HLP 压缩记录做字节验证，对所有源样本计算实际有效像元和全训练集统计。

eo_data/__init__.py ADDED Viewed

	@@ -0,0 +1,3 @@

+"""Shared independent-dataset reconstruction inputs."""
+from .dataset import EODataset, open_dataset, open_datasets, make_dataloader
+__all__=['EODataset','open_dataset','open_datasets','make_dataloader']

eo_data/__main__.py ADDED Viewed

	@@ -0,0 +1,59 @@

+import argparse
+import json
+from pathlib import Path
+from .core import dataset_name
+from .prepare import PROJECT, prepare_dataset
+def main():
+    parser=argparse.ArgumentParser(description='Unified EO data preparation and reading')
+    sub=parser.add_subparsers(dest='command',required=True)
+    p=sub.add_parser('prepare')
+    p.add_argument('--dataset',default='all')
+    p.add_argument('--root',type=Path,default=PROJECT)
+    p.add_argument('--output',type=Path)
+    p.add_argument('--workers',type=int,default=4)
+    p.add_argument('--level',type=int,default=3)
+    p.add_argument('--limit',type=int,help='Development subset only; rejected by the default training loader')
+    v=sub.add_parser('verify')
+    v.add_argument('--root',type=Path,default=PROJECT)
+    v.add_argument('--output',type=Path)
+    v.add_argument('--dataset',default='all')
+    v.add_argument('--samples',type=int,default=16)
+    v.add_argument('--allow-development',action='store_true')
+    r=sub.add_parser('restore-prithvi')
+    r.add_argument('--root',type=Path,default=PROJECT)
+    r.add_argument('--prepared',type=Path)
+    r.add_argument('--destination',type=Path,required=True)
+    r.add_argument('--limit',type=int)
+    a=sub.add_parser('archive-prithvi')
+    a.add_argument('--root',type=Path,default=PROJECT)
+    a.add_argument('--prepared',type=Path)
+    a.add_argument('--destination',type=Path,required=True)
+    a=sub.add_parser('attach-prithvi')
+    a.add_argument('archive',type=Path)
+    a.add_argument('--root',type=Path,default=PROJECT)
+    a.add_argument('--prepared',type=Path)
+    args=parser.parse_args()
+    if args.command=='prepare':
+        if args.workers<1 or args.workers>32:parser.error('workers must be 1..32')
+        if args.limit is not None and args.limit<1:parser.error('limit must be positive')
+        output=args.output or args.root/('processed_data/development' if args.limit else 'processed_data/v1')
+        names=['prithvi','lstsr_tb'] if args.dataset=='all' else [dataset_name(args.dataset)]
+        for name in names:prepare_dataset(args.root.resolve(),name,output.resolve(),args.workers,args.level,args.limit)
+    elif args.command=='verify':
+        from .verify import verify_all
+        print(json.dumps(verify_all(args.root,args.output,args.dataset,args.samples,args.allow_development),indent=2))
+    elif args.command=='restore-prithvi':
+        from .verify import restore_prithvi
+        print(json.dumps(restore_prithvi(args.root,args.prepared,args.destination,args.limit),indent=2))
+    elif args.command=='archive-prithvi':
+        from .archive import create_archive,attach_archive
+        report=create_archive(args.root,args.destination,args.prepared)
+        attach_archive(args.root,args.destination,args.prepared,report)
+        print(json.dumps(report,indent=2))
+    else:
+        from .archive import verify_archive,attach_archive
+        report=verify_archive(args.archive)
+        print(json.dumps(attach_archive(args.root,args.archive,args.prepared,report),indent=2))
+if __name__=='__main__':main()

eo_data/archive.py ADDED Viewed

	@@ -0,0 +1,175 @@

+"""ZIP64 container around seekable EOZ frames; no second lossy encoding."""
+from pathlib import Path
+import hashlib
+import json
+import os
+import struct
+import time
+import zipfile
+from .core import VERSION, json_write, sha256_file
+PREFIX = 'processed_data/v1/prithvi/'
+CONTENTS = 'ARCHIVE_CONTENTS.json'
+class ArchiveFrames:
+    def __init__(self, root, storage):
+        self.path = (Path(root)/storage['archive']).resolve()
+        stat = self.path.stat()
+        if stat.st_size != storage['size'] or stat.st_mtime_ns != storage['mtime_ns']:
+            raise ValueError('Archive changed or moved without reattaching; run attach-prithvi')
+        self.stream = self.path.open('rb')
+        with zipfile.ZipFile(self.path) as z:
+            entries = z.infolist()
+            if len(entries) != len({i.filename for i in entries}):
+                raise ValueError('Duplicate archive members')
+            self.entries = {i.filename: i for i in entries}
+        self.offsets = {}
+    def read(self, loc):
+        member = PREFIX+'packs/'+loc['shard']
+        info = self.entries[member]
+        if info.compress_type != zipfile.ZIP_STORED or info.flag_bits & 1:
+            raise ValueError('EOZ members must be stored and unencrypted for direct seeking')
+        if member not in self.offsets:
+            self.stream.seek(info.header_offset)
+            header = self.stream.read(30)
+            if header[:4] != b'PK\x03\x04':
+                raise ValueError('Invalid ZIP local header')
+            name_len, extra_len = struct.unpack_from('<HH', header, 26)
+            name = self.stream.read(name_len).decode('utf-8')
+            if name != member:
+                raise ValueError('ZIP local/central member mismatch')
+            self.offsets[member] = info.header_offset+30+name_len+extra_len
+        offset, length = loc['offset'], loc['length']
+        if offset < 0 or length <= 0 or offset+length > info.file_size:
+            raise ValueError('Frame exceeds stored shard')
+        self.stream.seek(self.offsets[member]+offset)
+        frame = self.stream.read(length)
+        if len(frame) != length:
+            raise ValueError('Truncated archive frame')
+        return frame
+    def close(self):
+        self.stream.close()
+def verify_archive(path):
+    path = Path(path).resolve()
+    started = time.time()
+    with zipfile.ZipFile(path) as z:
+        members = z.infolist()
+        manifest = json.loads(z.read(CONTENTS))
+        names = [i.filename for i in members]
+        if len(names) != len(set(names)) or set(names) != set(manifest['files']) | {CONTENTS}:
+            raise ValueError('Archive member inventory mismatch')
+        for n, (member, expected) in enumerate(manifest['files'].items(), 1):
+            info = z.getinfo(member)
+            if info.file_size != expected['size'] or info.compress_type != expected['compression']:
+                raise ValueError(f'Archive member schema mismatch: {member}')
+            h = hashlib.sha256()
+            with z.open(member) as source:
+                for block in iter(lambda: source.read(8*1024*1024), b''):
+                    h.update(block)
+            if h.hexdigest() != expected['sha256']:
+                raise ValueError(f'Archive content hash mismatch: {member}')
+            if n % 64 == 0:
+                print(json.dumps({'phase':'verify_archive','files':n,'total':len(manifest['files'])}), flush=True)
+        bundle = json.loads(z.read(PREFIX+'bundle.json'))
+        for shard in bundle['shards']:
+            assert manifest['files'][PREFIX+'packs/'+shard['name']]['sha256'] == shard['sha256']
+    print('Archive members verified; computing whole-file SHA-256', flush=True)
+    digest = sha256_file(path)
+    report = {'status':'passed','path':str(path),'size':path.stat().st_size,'mtime_ns':path.stat().st_mtime_ns,
+              'sha256':digest,'members':len(members),'records':bundle['records'],
+              'all_member_sha256_verified':True,'seconds':time.time()-started}
+    json_write(path.with_suffix(path.suffix+'.verification.json'), report)
+    path.with_suffix(path.suffix+'.sha256').write_text(f'{digest}  {path.name}\n', encoding='utf-8')
+    return report
+def create_archive(root, destination, prepared=None):
+    root = Path(root).resolve()
+    directory = Path(prepared or root/'processed_data/v1')/'prithvi'
+    destination = Path(destination).resolve()
+    if destination.exists():
+        raise FileExistsError(destination)
+    temporary = destination.with_suffix(destination.suffix+'.partial')
+    if temporary.exists():
+        raise FileExistsError(f'Previous partial archive needs inspection: {temporary}')
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    bundle = json.loads((directory/'bundle.json').read_text(encoding='utf-8'))
+    if bundle['status'] != 'ready' or not bundle['all_packed_records_byte_verified']:
+        raise ValueError('A completed and byte-verified Prithvi build is required')
+    expected = {PREFIX+'packs/'+s['name']:s['sha256'] for s in bundle['shards']}
+    expected.update({PREFIX+k:v for k,v in bundle['artifacts'].items()})
+    expected.update({PREFIX+v['index']:v['sha256'] for v in bundle['samples'].values()})
+    expected.update({PREFIX+'original_aux/'+k:v['sha256'] for k,v in bundle['auxiliary'].items()})
+    files = [(directory/'packs'/s['name'], PREFIX+'packs/'+s['name'], zipfile.ZIP_STORED) for s in bundle['shards']]
+    excluded = {'storage.json','.prepare.lock'}
+    for p in sorted(directory.rglob('*')):
+        if p.is_file() and p.parent != directory/'packs' and p.name not in excluded and not p.name.endswith(('-wal','-shm','.tmp')):
+            files.append((p, PREFIX+p.relative_to(directory).as_posix(), zipfile.ZIP_DEFLATED))
+    package = Path(__file__).parent
+    for p in sorted(package.glob('*.py')) + [package/'README.md',package/'requirements.txt']:
+        if p.exists(): files.append((p,'eo_data/'+p.name,zipfile.ZIP_DEFLATED))
+    manifest = {'format':'eoz-in-zip64-v1','dataset':'prithvi','data_version':VERSION,'files':{}}
+    with zipfile.ZipFile(temporary,'w',allowZip64=True,compresslevel=3) as z:
+        for n,(source,member,compression) in enumerate(files,1):
+            info = zipfile.ZipInfo(member, time.localtime(source.stat().st_mtime)[:6])
+            info.compress_type = compression
+            info.external_attr = 0o100644 << 16
+            h = hashlib.sha256(); size = 0
+            with source.open('rb') as src, z.open(info,'w',force_zip64=True) as dst:
+                for block in iter(lambda: src.read(8*1024*1024), b''):
+                    h.update(block); dst.write(block); size += len(block)
+            digest = h.hexdigest()
+            if member in expected and digest != expected[member]:
+                raise ValueError(f'Frozen source changed while archiving: {source}')
+            manifest['files'][member] = {'size':size,'sha256':digest,'compression':compression}
+            if n % 32 == 0 or n == len(files):
+                print(json.dumps({'phase':'create_archive','files':n,'total':len(files),'GiB_written':temporary.stat().st_size/2**30}),flush=True)
+        z.writestr(CONTENTS,json.dumps(manifest,indent=2).encode(),compress_type=zipfile.ZIP_DEFLATED)
+    temporary.replace(destination)
+    return verify_archive(destination)
+def attach_archive(root, archive, prepared=None, verified_report=None):
+    root = Path(root).resolve(); archive = Path(archive).resolve()
+    directory = Path(prepared or root/'processed_data/v1')/'prithvi'
+    directory.mkdir(parents=True,exist_ok=True)
+    with zipfile.ZipFile(archive) as z:
+        manifest = json.loads(z.read(CONTENTS))
+        bundle = json.loads(z.read(PREFIX+'bundle.json'))
+        if bundle['version'] != VERSION or bundle['dataset'] != 'prithvi':
+            raise ValueError('Unsupported dataset archive')
+        frozen = set(bundle['artifacts']) | {'bundle.json'} | {v['index'] for v in bundle['samples'].values()}
+        frozen |= {'original_aux/'+k for k in bundle['auxiliary']}
+        for member, expected in manifest['files'].items():
+            if not member.startswith(PREFIX) or member.startswith(PREFIX+'packs/'):
+                continue
+            relative = member[len(PREFIX):]
+            target = (directory/relative).resolve()
+            if not target.is_relative_to(directory.resolve()):
+                raise ValueError('Unsafe archive path')
+            payload = z.read(member)
+            if hashlib.sha256(payload).hexdigest() != expected['sha256']:
+                raise ValueError(f'Archive metadata hash mismatch: {member}')
+            if target.exists():
+                if relative in frozen and sha256_file(target) != expected['sha256']:
+                    raise ValueError(f'Existing frozen metadata differs: {target}')
+            else:
+                target.parent.mkdir(parents=True,exist_ok=True)
+                target.write_bytes(payload)
+    stat = archive.stat()
+    storage = {'backend':'zip64_eoz','archive':archive.relative_to(root).as_posix() if archive.is_relative_to(root) else str(archive),
+               'size':stat.st_size,'mtime_ns':stat.st_mtime_ns,'archive_sha256':None}
+    if verified_report:
+        if (verified_report['status']!='passed' or verified_report['size']!=stat.st_size
+                or Path(verified_report['path']).resolve()!=archive
+                or verified_report['mtime_ns']!=stat.st_mtime_ns):
+            raise ValueError('Archive verification report mismatch')
+        storage['archive_sha256'] = verified_report['sha256']
+    json_write(directory/'storage.json',storage)
+    return storage

eo_data/codec.py ADDED Viewed

	@@ -0,0 +1,52 @@

+"""Independently decodable, byte-exact Prithvi sample frames."""
+import hashlib
+import struct
+import numpy as np
+import zstandard as zstd
+MAGIC = b'EOZ1'
+FILENAMES = ('bands.npy', 'fmask.npy', 'lst.npy', 'metadata.json')
+def _encode_words(raw):
+    if len(raw) % 2:
+        raise ValueError('Word transform requires even byte count')
+    words = np.frombuffer(raw, dtype='<u2')
+    delta = np.empty_like(words)
+    delta[:1] = words[:1]
+    np.subtract(words[1:], words[:-1], out=delta[1:])
+    return delta.view(np.uint8).reshape(-1, 2).T.copy().tobytes()
+def _decode_words(raw):
+    delta = np.frombuffer(raw, dtype=np.uint8).reshape(2, -1).T.copy().view('<u2').reshape(-1)
+    return np.cumsum(delta, dtype=np.uint16).astype('<u2', copy=False).tobytes()
+def original_digest(parts):
+    h = hashlib.sha256()
+    for part in parts:
+        h.update(struct.pack('<Q', len(part)))
+        h.update(part)
+    return h.hexdigest()
+def encode(parts, level=3):
+    if len(parts) != 4:
+        raise ValueError('Expected four original files')
+    payload = MAGIC + struct.pack('<4I', *(len(p) for p in parts))
+    payload += _encode_words(parts[0]) + parts[1] + _encode_words(parts[2]) + parts[3]
+    return zstd.ZstdCompressor(level=level, write_checksum=True).compress(payload)
+def decode(frame, expected_digest=None):
+    raw = zstd.ZstdDecompressor().decompress(frame, max_output_size=16 * 1024 * 1024)
+    if raw[:4] != MAGIC:
+        raise ValueError('Unsupported sample frame')
+    lengths = struct.unpack('<4I', raw[4:20])
+    if sum(lengths) + 20 != len(raw):
+        raise ValueError('Invalid sample lengths')
+    parts = []
+    offset = 20
+    for i, n in enumerate(lengths):
+        part = raw[offset:offset+n]
+        parts.append(_decode_words(part) if i in (0, 2) else part)
+        offset += n
+    if expected_digest and original_digest(parts) != expected_digest:
+        raise ValueError('Decoded content hash mismatch')
+    return parts

eo_data/core.py ADDED Viewed

	@@ -0,0 +1,107 @@

+"""Canonical masks, sample-balanced statistics, and normalization."""
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+VERSION = 'eo-independent-reconstruction-v1'
+BANDS = ('Blue', 'Green', 'Red', 'NIR', 'SWIR1', 'SWIR2')
+ALIASES = {'prithvi': 'prithvi', 'prithvi_data': 'prithvi',
+           'lstsr_tb': 'lstsr_tb', 'lstsr': 'lstsr_tb',
+           'lstsr_tb_final_upload_20260721': 'lstsr_tb'}
+def dataset_name(name):
+    try:
+        return ALIASES[name]
+    except KeyError:
+        raise ValueError(f'Unknown dataset {name!r}; use prithvi or lstsr_tb') from None
+def modality_name(name):
+    if name in ('lst', 'lst_hr'):
+        return 'lst_hr'
+    if name == 'hls':
+        return name
+    raise ValueError('Use hls or lst_hr (alias lst)')
+def sha256_file(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for block in iter(lambda: f.read(8 * 1024 * 1024), b''):
+            h.update(block)
+    return h.hexdigest()
+def json_write(path, value):
+    path = Path(path)
+    temp = path.with_suffix(path.suffix + '.tmp')
+    temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False), encoding='utf-8')
+    temp.replace(path)
+def canonical(raw, modality, dataset, fmask=None, source_valid=None):
+    """Decode each source without clipping, resizing, or per-image fitting."""
+    modality = modality_name(modality)
+    raw = np.asarray(raw)
+    if modality == 'hls':
+        if raw.shape != (6, 256, 256) or raw.dtype != np.int16:
+            raise ValueError(f'Unexpected HLS schema {raw.shape}, {raw.dtype}')
+        if fmask is None or fmask.shape != (256, 256) or fmask.dtype != np.uint8:
+            raise ValueError('Expected uint8 HLS Fmask [256,256]')
+        fill = (-9999, -32767, -32768) if dataset == 'prithvi' else (-32768,)
+        valid = ~np.isin(raw, fill).any(axis=0)
+        valid &= (fmask != 255) & ((fmask & 14) == 0)
+        scale = 0.0001
+    else:
+        if raw.shape != (256, 256) or raw.dtype != np.int16:
+            raise ValueError(f'Unexpected HR LST schema {raw.shape}, {raw.dtype}')
+        fill = (-32767,) if dataset == 'prithvi' else (-32768,)
+        valid = ~np.isin(raw, fill)
+        raw = raw[None]
+        scale = 1.0  # Explicit raw-coded LST; no unverified temperature unit.
+    if source_valid is not None:
+        if source_valid.shape != (256, 256):
+            raise ValueError('Invalid source mask shape')
+        valid &= source_valid.astype(bool)
+    image = raw.astype(np.float32) * np.float32(scale)
+    return image, valid[None]
+def sample_moments(image, mask):
+    n = int(mask.sum())
+    if n == 0:
+        return None
+    values = image[:, mask[0]].astype(np.float64)
+    return {'pixels': n, 'mean': values.mean(axis=1).tolist(),
+            'second': np.square(values).mean(axis=1).tolist()}
+def empty_accumulator(channels):
+    return {'samples': 0, 'pixels': 0, 'sum_mean': [0.0]*channels, 'sum_second': [0.0]*channels}
+def accumulate(acc, moments):
+    if moments is None:
+        return
+    acc['samples'] += 1
+    acc['pixels'] += moments['pixels']
+    acc['sum_mean'] = (np.asarray(acc['sum_mean']) + moments['mean']).tolist()
+    acc['sum_second'] = (np.asarray(acc['sum_second']) + moments['second']).tolist()
+def finish_stats(acc, modality):
+    if not acc['samples']:
+        raise ValueError(f'No valid training samples for {modality}')
+    mean = np.asarray(acc['sum_mean']) / acc['samples']
+    variance = np.maximum(np.asarray(acc['sum_second']) / acc['samples'] - mean**2, 0)
+    std = np.sqrt(variance)
+    return {'mean': mean.tolist(), 'std': np.maximum(std, 1e-6).tolist(),
+            'unfloored_std': std.tolist(), 'std_floor': 1e-6,
+            'samples': acc['samples'], 'valid_spatial_pixels': acc['pixels'],
+            'fit_split': 'train', 'weighting': 'equal_samples_then_equal_valid_pixels_within_sample',
+            'units': 'reflectance' if modality == 'hls' else 'source_raw_int16_units',
+            'physical_temperature_unit_confirmed': False if modality == 'lst_hr' else None}
+def normalize(image, mask, stats):
+    mean = np.asarray(stats['mean'], np.float32)[:, None, None]
+    std = np.asarray(stats['std'], np.float32)[:, None, None]
+    return np.where(mask, (image - mean) / std, np.float32(0)).astype(np.float32)
+def denormalize(image, stats):
+    """Channel axis is -3; supports [C,H,W] and [B,C,H,W]."""
+    shape = [1] * np.ndim(image)
+    shape[-3] = len(stats['mean'])
+    return np.asarray(image) * np.asarray(stats['std'], np.float32).reshape(shape) + np.asarray(stats['mean'], np.float32).reshape(shape)

eo_data/dataset.py ADDED Viewed

	@@ -0,0 +1,199 @@

+"""One public dataset interface for packed Prithvi and original LSTSR NPZ."""
+from collections import OrderedDict
+from pathlib import Path
+import hashlib
+import io
+import json
+import os
+import sqlite3
+import numpy as np
+from . import codec
+from .core import VERSION, canonical, dataset_name, denormalize, modality_name, normalize, sha256_file
+PROJECT = Path(__file__).resolve().parents[1]
+_VERIFIED = {}
+class EODataset:
+    """NumPy map-style dataset; compatible with PyTorch's default collator.
+    Connections/caches are opened per process; images and targets never alias.
+    Index may be int or (epoch,int). No augmentation/noise is enabled in v1.
+    """
+    def __init__(self, dataset, modality, split='train', root=None, prepared=None,
+                 verify=True, allow_development=False):
+        self.root = Path(root or PROJECT).resolve()
+        self.name = dataset_name(dataset)
+        self.modality = modality_name(modality)
+        self.split = split
+        self.directory = Path(prepared or self.root/'processed_data/v1').resolve()/self.name
+        manifest = self.directory/'bundle.json'
+        if not manifest.exists():
+            raise FileNotFoundError(f'Preprocessing not complete: {manifest}. Run python -m eo_data prepare --dataset {self.name}')
+        self.bundle = json.loads(manifest.read_text(encoding='utf-8'))
+        if self.bundle['status'] != 'ready' or self.bundle['version'] != VERSION:
+            raise ValueError('Unsupported/incomplete prepared dataset')
+        for name in ('core.py','codec.py'):
+            if sha256_file(Path(__file__).parent/name) != self.bundle['identity']['pipeline_sha256'][name]:
+                raise ValueError(f'Processing code differs from the frozen data: {name}')
+        if self.bundle['scope'] != 'full' and not allow_development:
+            raise ValueError('Development subset cannot be used as a full training dataset')
+        key = f'{split}/{self.modality}'
+        if key not in self.bundle['samples']:
+            raise ValueError(f'No {key} split in {self.name}; available: {list(self.bundle["samples"])}')
+        entry = self.bundle['samples'][key]
+        if verify:
+            checks = dict(self.bundle['artifacts'])
+            checks[entry['index']] = entry['sha256']
+            for relative, expected in checks.items():
+                path = self.directory/relative
+                st = path.stat()
+                cache_key = (str(path),st.st_size,st.st_mtime_ns,expected)
+                if cache_key not in _VERIFIED:
+                    if sha256_file(path) != expected:
+                        raise ValueError(f'Frozen artifact changed: {path}')
+                    _VERIFIED[cache_key] = True
+        self.index_path = self.directory/entry['index']
+        self.indices = np.load(self.index_path,mmap_mode='r',allow_pickle=False)
+        if self.indices.shape != (entry['samples'],3):raise ValueError('Invalid sample index')
+        self.stats = json.loads((self.directory/self.bundle['normalization']).read_text(encoding='utf-8'))[self.modality]
+        self.source = self.root/self.bundle['source_root']
+        storage_file = self.directory/'storage.json'
+        self.storage = json.loads(storage_file.read_text(encoding='utf-8')) if storage_file.exists() else None
+        self._archive_reader = None
+        self._pid = None;self._db = None;self._pack_files = OrderedDict();self._npz_cache = OrderedDict()
+        self.fingerprint = {'dataset':self.name,'modality':self.modality,'split':self.split,
+                            'protocol':self.bundle['identity']['protocol_sha256'],
+                            'sample_index':entry['sha256'],
+                            'normalization':self.bundle['artifacts']['normalization.json'],
+                            'source_index':self.bundle['identity']['source_index_sha256'],
+                            'record_index':self.bundle['artifacts']['index.sqlite'],
+                            'reader_code':sha256_file(Path(__file__)),
+                            'processing_code':self.bundle['identity']['pipeline_sha256']}
+    def __len__(self):return len(self.indices)
+    def _connect(self):
+        if self._pid != os.getpid():
+            self.close()
+            self._pid = os.getpid()
+        if self._db is None:
+            uri=(self.directory/'index.sqlite').as_uri()+'?mode=ro&immutable=1'
+            self._db=sqlite3.connect(uri,uri=True)
+        return self._db
+    def _record(self, index):
+        if isinstance(index, tuple):_,index=index
+        index=int(index)
+        if index<0:index+=len(self)
+        if not 0<=index<len(self):raise IndexError(index)
+        rid,slot,count=map(int,self.indices[index])
+        row=self._connect().execute('SELECT key,tile,meta,loc,digest FROM records WHERE id=?',(rid,)).fetchone()
+        if row is None:raise ValueError('Record missing from frozen index')
+        return index,rid,slot,count,row
+    def _parts(self, loc, digest=None):
+        if self.storage is not None:
+            from .archive import ArchiveFrames
+            if self._archive_reader is None:
+                self._archive_reader = ArchiveFrames(self.root,self.storage)
+            return codec.decode(self._archive_reader.read(loc),digest)
+        shard=loc['shard']
+        if shard not in self._pack_files:
+            self._pack_files[shard]=(self.directory/'packs'/shard).open('rb')
+            if len(self._pack_files)>8:self._pack_files.popitem(last=False)[1].close()
+        self._pack_files.move_to_end(shard)
+        stream=self._pack_files[shard]
+        stream.seek(loc['offset'])
+        frame=stream.read(loc['length'])
+        if len(frame)!=loc['length']:raise ValueError('Truncated compressed frame')
+        return codec.decode(frame,digest)
+    def _npz(self, loc):
+        kind='hls' if self.modality=='hls' else 'lst'
+        relative=loc[kind]
+        path=(self.source/relative).resolve()
+        if not path.is_relative_to(self.source.resolve()):raise ValueError('Source path escapes root')
+        expected=loc['source_signatures'][kind]
+        stat=path.stat()
+        if stat.st_size!=expected['size'] or stat.st_mtime_ns!=expected['mtime_ns']:
+            raise ValueError(f'Source file changed since preprocessing: {path}. Revalidate/rebuild before training.')
+        if relative not in self._npz_cache:
+            with np.load(path,allow_pickle=False) as z:
+                if kind=='hls':value=(z['hls_reflectance_i16'],z['hls_fmask'],z['hls_valid'])
+                else:value=(z['hr_lst'],z['hr_valid'])
+            self._npz_cache[relative]=value
+            if len(self._npz_cache)>2:self._npz_cache.popitem(last=False)
+        self._npz_cache.move_to_end(relative)
+        return self._npz_cache[relative]
+    def __getitem__(self, index):
+        _,rid,slot,count,row=self._record(index)
+        key,tile,_,loc_text,digest=row
+        loc=json.loads(loc_text)
+        if self.name=='prithvi':
+            parts=self._parts(loc)
+            raw=np.load(io.BytesIO(parts[0 if self.modality=='hls' else 2]),allow_pickle=False)
+            f=np.load(io.BytesIO(parts[1]),allow_pickle=False) if self.modality=='hls' else None
+            image,mask=canonical(raw,self.modality,self.name,fmask=f)
+        elif self.modality=='hls':
+            raw,f,valid=self._npz(loc)
+            image,mask=canonical(raw,self.modality,self.name,fmask=f,source_valid=valid)
+        else:
+            raw,valid=self._npz(loc)
+            image,mask=canonical(raw[slot],self.modality,self.name,source_valid=valid[slot])
+        if int(mask.sum())!=count:raise ValueError(f'Validity policy/source drift at {key}')
+        image=normalize(image,mask,self.stats)
+        sample_id=f'{self.name}:{key}:{self.modality}'+(f':m{slot+1:02d}' if slot>=0 else '')
+        return {'image':image,'target':image.copy(),'reference_mask':mask.copy(),'input_mask':mask.copy(),
+                'corruption_mask':np.zeros_like(mask),'sample_id':sample_id,'dataset_id':self.name,
+                'modality':self.modality,'split':self.split,'tile_id':tile,'month':slot+1 if slot>=0 else 0,
+                'valid_pixels':count}
+    def get_metadata(self,index):
+        *_,row=self._record(index)
+        return json.loads(row[2])
+    def denormalize(self, image):return denormalize(image,self.stats)
+    def epoch_indices(self, epoch, seed=20260909):
+        digest=hashlib.sha256(f'{seed}:{epoch}:{self.name}:{self.modality}:{self.split}'.encode()).digest()
+        rng=np.random.Generator(np.random.PCG64(int.from_bytes(digest[:16],'little')))
+        return rng.permutation(len(self))
+    def close(self):
+        if getattr(self,'_archive_reader',None) is not None:
+            self._archive_reader.close();self._archive_reader=None
+        if getattr(self,'_db',None) is not None:self._db.close();self._db=None
+        for stream in getattr(self,'_pack_files',{}).values():stream.close()
+        self._pack_files=OrderedDict();self._npz_cache=OrderedDict()
+    def __getstate__(self):
+        state=dict(self.__dict__)
+        state.update(_db=None,_pid=None,_pack_files=OrderedDict(),_npz_cache=OrderedDict(),indices=None,_archive_reader=None)
+        return state
+    def __setstate__(self,state):
+        self.__dict__.update(state)
+        self.indices=np.load(self.index_path,mmap_mode='r',allow_pickle=False)
+    def __del__(self):
+        try:self.close()
+        except Exception:pass
+def open_dataset(dataset, modality, split='train', **kwargs):
+    return EODataset(dataset,modality,split,**kwargs)
+def open_datasets(split='train', **kwargs):
+    return {name:{mod:open_dataset(name,mod,split,**kwargs) for mod in ('hls','lst')}
+            for name in ('prithvi','lstsr_tb')}
+def make_dataloader(dataset, modality, split='train', batch_size=16, num_workers=0, seed=20260909, **dataset_kwargs):
+    try:
+        import torch
+        from torch.utils.data import DataLoader
+    except ImportError as e:
+        raise ImportError('PyTorch is optional for NumPy reads; install it in your training environment to use make_dataloader.') from e
+    ds=open_dataset(dataset,modality,split,**dataset_kwargs)
+    generator=torch.Generator().manual_seed(seed)
+    return DataLoader(ds,batch_size=batch_size,shuffle=split=='train',num_workers=num_workers,
+                      generator=generator,persistent_workers=num_workers>0,drop_last=False)

eo_data/locking.py ADDED Viewed

	@@ -0,0 +1,33 @@

+"""OS-held per-output writer lock; automatically released after a crash."""
+from contextlib import contextmanager
+from pathlib import Path
+import os
+@contextmanager
+def build_lock(directory):
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    stream = (directory/'.prepare.lock').open('a+b')
+    if stream.seek(0,2) == 0:
+        stream.write(b'0'); stream.flush()
+    stream.seek(0)
+    try:
+        if os.name == 'nt':
+            import msvcrt
+            msvcrt.locking(stream.fileno(),msvcrt.LK_NBLCK,1)
+        else:
+            import fcntl
+            fcntl.flock(stream.fileno(),fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError as e:
+        stream.close()
+        raise RuntimeError(f'Another preprocessing writer is using {directory}') from e
+    try:
+        yield
+    finally:
+        stream.seek(0)
+        if os.name == 'nt':
+            msvcrt.locking(stream.fileno(),msvcrt.LK_UNLCK,1)
+        else:
+            fcntl.flock(stream.fileno(),fcntl.LOCK_UN)
+        stream.close()

eo_data/prepare.py ADDED Viewed

	@@ -0,0 +1,346 @@

+"""Resumable full census, train-only fitting, and verified lossless packing."""
+from collections import Counter, deque
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+import csv
+import hashlib
+import io
+import json
+import os
+import shutil
+import sqlite3
+import subprocess
+import time
+import numpy as np
+from . import codec
+from .core import (VERSION, BANDS, accumulate, canonical, empty_accumulator,
+                   finish_stats, json_write, sample_moments, sha256_file)
+PROJECT = Path(__file__).resolve().parents[1]
+CHUNK = 512
+def safe_path(root, relative):
+    root = Path(root).resolve()
+    path = (root / relative).resolve()
+    if not path.is_relative_to(root):
+        raise ValueError(f'Path escapes source root: {relative}')
+    return path
+def bounded_map(pool, fn, items, width):
+    it = iter(items)
+    pending = deque()
+    for _ in range(width):
+        try: pending.append(pool.submit(fn, next(it)))
+        except StopIteration: break
+    while pending:
+        yield pending.popleft().result()
+        try: pending.append(pool.submit(fn, next(it)))
+        except StopIteration: pass
+def file_signature(path):
+    s = path.stat()
+    return {'size': s.st_size, 'mtime_ns': s.st_mtime_ns}
+def create_index(project, name, out, limit=None):
+    index = out / 'source_index.jsonl'
+    if index.exists() and (out/'source_info.json').exists():
+        info = json.loads((out/'source_info.json').read_text(encoding='utf-8'))
+        if info['limit'] != limit:
+            raise ValueError('Cannot change a partial/full build scope in an existing output')
+        for rel, digest in info['source_manifest_hashes'].items():
+            if sha256_file(project/rel) != digest:
+                raise ValueError(f'Source manifest changed: {rel}')
+        if sha256_file(index) != info['index_sha256']:
+            raise ValueError('Source index changed')
+        return info
+    temp = index.with_suffix('.building')
+    hashes = {}
+    counts = Counter()
+    candidate = Counter()
+    count = 0
+    if name == 'prithvi':
+        source = project/'prithvi_data'
+        if shutil.which('rg'):
+            paths = subprocess.check_output(['rg','--files','--hidden','--no-ignore',str(source)], text=True).splitlines()
+            rels = [Path(p).relative_to(source).as_posix() for p in paths]
+        else:
+            rels = [p.relative_to(source).as_posix() for p in source.rglob('*') if p.is_file()]
+        groups = {}
+        extra = []
+        for rel in rels:
+            if rel.startswith(('train/','val/')):
+                parent, base = rel.rsplit('/', 1)
+                groups.setdefault(parent, set()).add(base)
+            else:
+                extra.append(rel)
+        with temp.open('w', encoding='utf-8', newline='\n') as f:
+            for key, members in sorted(groups.items()):
+                if set(codec.FILENAMES) != members:
+                    raise ValueError(f'Unexpected/missing files at {key}: {members}')
+                split, tile, obs, patch = key.split('/')
+                int(obs.removeprefix('obs_'))
+                row, col = patch.split('_')
+                int(row[1:]); int(col[1:])
+                record = {'id': count+1, 'key': key, 'split': split, 'tile': tile,
+                          'loc': {'path': key}}
+                f.write(json.dumps(record, separators=(',',':'))+'\n')
+                count += 1; counts[split] += 1
+                candidate[f'{split}/hls'] += 1; candidate[f'{split}/lst_hr'] += 1
+                if limit and count >= limit: break
+        aux = out/'original_aux'
+        aux.mkdir(exist_ok=True)
+        auxiliary = {}
+        for rel in extra:
+            src = safe_path(source, rel)
+            dst = safe_path(aux, rel)
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+            auxiliary[rel] = {'sha256': sha256_file(dst), **file_signature(src)}
+        root_rel = 'prithvi_data'
+    else:
+        root_rel = 'data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719'
+        source = project/root_rel
+        hls_rel = 'hls_l8_conditions_2019_2025_lc08'
+        manifests = [source/'phase4_dataset_manifest.csv', source/hls_rel/'hls_condition_manifest.csv']
+        for p in manifests: hashes[p.relative_to(project).as_posix()] = sha256_file(p)
+        hls = {}
+        with manifests[1].open(encoding='utf-8', newline='') as f:
+            for r in csv.DictReader(f):
+                key = r['sequence_id']
+                if key in hls: raise ValueError(f'Duplicate HLS key: {key}')
+                if r['reflectance_bands'] != 'B2,B3,B4,B5,B6,B7' or float(r['reflectance_scale']) != 0.0001:
+                    raise ValueError(f'Unexpected HLS band/scale at {key}')
+                hls[key] = {k:r[k] for k in ['archive','split','mgrs_tile','hls_datetime_utc','hls_image_id']}
+        seen = set()
+        with manifests[0].open(encoding='utf-8', newline='') as src, temp.open('w', encoding='utf-8', newline='\n') as dst:
+            for r in csv.DictReader(src):
+                key = r['sequence_id']
+                if key in seen: raise ValueError(f'Duplicate LST key: {key}')
+                seen.add(key)
+                h = hls[key]
+                if (r['split'],r['mgrs_tile']) != (h['split'],h['mgrs_tile']):
+                    raise ValueError(f'LST/HLS membership mismatch at {key}')
+                if int(r['nodata_i16']) != -32768 or int(r['patch_size']) != 256:
+                    raise ValueError(f'Unexpected source encoding at {key}')
+                months = [int(m)-1 for m in r['available_months'].split(',')]
+                if len(set(months)) != len(months) or any(m not in range(12) for m in months) or len(months)!=int(r['available_month_count']):
+                    raise ValueError(f'Invalid availability at {key}')
+                loc = {'lst': r['archive'], 'hls': hls_rel+'/'+h['archive'], 'slots': sorted(months)}
+                safe_path(source, loc['lst']); safe_path(source, loc['hls'])
+                record = {'id':count+1,'key':key,'split':r['split'],'tile':r['mgrs_tile'],'loc':loc,
+                          'meta':{'sequence_id':key,'month_dates':json.loads(r['month_dates_json']),
+                                  'hls_datetime':h['hls_datetime_utc'],'hls_image_id':h['hls_image_id'],
+                                  'qa_version':r['qa_version'],'source_split':r['split']}}
+                dst.write(json.dumps(record, separators=(',',':'))+'\n')
+                count += 1; counts[r['split']] += 1
+                candidate[f"{r['split']}/hls"] += 1
+                candidate[f"{r['split']}/lst_hr"] += len(months)
+                if limit and count >= limit: break
+        if not limit and seen != set(hls): raise ValueError('LST and HLS manifest key sets differ')
+        auxiliary = {}
+    temp.replace(index)
+    info = {'dataset':name,'source_root':root_rel,'records':count,'record_counts':dict(counts),
+            'candidate_samples':dict(candidate),'source_manifest_hashes':hashes,
+            'index_sha256':sha256_file(index),'auxiliary':auxiliary,'limit':limit}
+    json_write(out/'source_info.json', info)
+    return info
+def inspect_record(record, source, name, level):
+    """Each worker loads one complete source record; no validation fitting."""
+    fit = record['split'] == 'train'
+    result = {'record':record,'samples':[], 'frame':None, 'raw_bytes':0}
+    if name == 'prithvi':
+        folder = safe_path(source, record['loc']['path'])
+        paths = [folder/n for n in codec.FILENAMES]
+        signatures = [file_signature(p) for p in paths]
+        parts = [p.read_bytes() for p in paths]
+        if [file_signature(p) for p in paths] != signatures:
+            raise ValueError(f'Source changed during read: {folder}')
+        meta = json.loads(parts[3])
+        b, f, l = [np.load(io.BytesIO(p), allow_pickle=False) for p in parts[:3]]
+        split,tile,obs,patch = record['key'].split('/')
+        row,col = patch.split('_')
+        if (meta['split'],meta['tile'],meta['obs_idx'],meta['row'],meta['col']) != (split,tile,int(obs[4:]),int(row[1:]),int(col[1:])):
+            raise ValueError(f'Metadata/path mismatch: {record["key"]}')
+        if tuple(meta['bands']) != BANDS or meta['bands_scale'] != 10000 or meta['lst_scale'] != 100:
+            raise ValueError(f'Unexpected scale/bands: {record["key"]}')
+        result.update(meta=meta,digest=codec.original_digest(parts),frame=codec.encode(parts,level),
+                      signatures=signatures,raw_bytes=sum(map(len,parts)))
+        arrays = [('hls',-1,*canonical(b,'hls',name,fmask=f)),
+                  ('lst_hr',-1,*canonical(l,'lst_hr',name))]
+    else:
+        loc = record['loc']
+        hp, lp = safe_path(source,loc['hls']), safe_path(source,loc['lst'])
+        signatures = {'hls':file_signature(hp),'lst':file_signature(lp)}
+        with np.load(hp,allow_pickle=False) as z:
+            b, f, v = z['hls_reflectance_i16'], z['hls_fmask'], z['hls_valid']
+        with np.load(lp,allow_pickle=False) as z:
+            l, lv = z['hr_lst'], z['hr_valid']
+        if l.shape != (12,256,256) or lv.shape != l.shape or l.dtype != np.int16:
+            raise ValueError(f'Invalid month bundle: {record["key"]}')
+        if {'hls':file_signature(hp),'lst':file_signature(lp)} != signatures:
+            raise ValueError(f'Source changed during read: {record["key"]}')
+        digest = hashlib.sha256()
+        for array in (b,f,v,l,lv): digest.update(array.tobytes(order='C'))
+        result.update(meta=record['meta'],digest=digest.hexdigest(),signatures=signatures,
+                      raw_bytes=signatures['hls']['size']+signatures['lst']['size'])
+        arrays = [('hls',-1,*canonical(b,'hls',name,fmask=f,source_valid=v))]
+        for slot in loc['slots']:
+            arrays.append(('lst_hr',slot,*canonical(l[slot],'lst_hr',name,source_valid=lv[slot])))
+    for modality,slot,image,mask in arrays:
+        n = int(mask.sum())
+        result['samples'].append((modality,slot,n,sample_moments(image,mask) if fit and n else None))
+    return result
+def init_db(path):
+    db = sqlite3.connect(path)
+    db.execute('PRAGMA journal_mode=WAL')
+    db.executescript('''
+    CREATE TABLE IF NOT EXISTS records(id INTEGER PRIMARY KEY, key TEXT UNIQUE, split TEXT, tile TEXT, meta TEXT, loc TEXT, digest TEXT);
+    CREATE TABLE IF NOT EXISTS samples(modality TEXT, split TEXT, record_id INTEGER, slot INTEGER, valid_pixels INTEGER, UNIQUE(modality,record_id,slot));
+    CREATE TABLE IF NOT EXISTS rejected(record_id INTEGER, modality TEXT, slot INTEGER, reason TEXT);
+    CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value TEXT);
+    CREATE TABLE IF NOT EXISTS shards(name TEXT PRIMARY KEY, bytes INTEGER, sha256 TEXT, records INTEGER, verified INTEGER);
+    ''')
+    return db
+def _read_setting(db, key):
+    row = db.execute('SELECT value FROM settings WHERE key=?',(key,)).fetchone()
+    return json.loads(row[0]) if row else None
+def prepare_dataset(project, name, output, workers=4, level=3, limit=None):
+    from .locking import build_lock
+    with build_lock(Path(output)/name):
+        return _prepare_dataset(project,name,output,workers,level,limit)
+def _prepare_dataset(project, name, output, workers=4, level=3, limit=None):
+    started = time.time()
+    out = output/name
+    out.mkdir(parents=True, exist_ok=True)
+    if (out/'bundle.json').exists():
+        bundle = json.loads((out/'bundle.json').read_text(encoding='utf-8'))
+        if bundle['identity']['limit'] != limit or bundle['identity']['zstd_level'] != level:
+            raise ValueError('Completed output has a different build scope/configuration')
+        print(f'{name}: already complete; keeping frozen output',flush=True)
+        return bundle
+    info = create_index(project,name,out,limit)
+    source = project/info['source_root']
+    db = init_db(out/'index.sqlite')
+    protocol = json.loads((project/'experiments/data/protocol.json').read_text(encoding='utf-8'))
+    if protocol['training_scope'] != 'independent_datasets': raise ValueError('This pipeline requires independent datasets')
+    identity = {'protocol_sha256':sha256_file(project/'experiments/data/protocol.json'),
+                'pipeline_sha256':{p.name:sha256_file(p) for p in Path(__file__).parent.glob('*.py')},
+                'source_index_sha256':info['index_sha256'],'zstd_level':level,'limit':limit}
+    saved = _read_setting(db,'identity')
+    if saved and saved != identity: raise ValueError('Build identity changed; use a new output version')
+    if not saved:
+        db.execute('INSERT INTO settings VALUES (?,?)',('identity',json.dumps(identity)))
+        db.commit()
+        json_write(out/'protocol.json',protocol)
+    state = _read_setting(db,'progress') or {'completed_records':0,'raw_bytes':0,'packed_bytes':0,
+        'train_accumulators':{'hls':empty_accumulator(6),'lst_hr':empty_accumulator(1)},'elapsed_seconds':0.0}
+    prior_time = state['elapsed_seconds']
+    def records():
+        with (out/'source_index.jsonl').open(encoding='utf-8') as f:
+            for line in f:
+                r=json.loads(line)
+                if r['id'] > state_start: yield r
+    state_start = state['completed_records']
+    it = iter(records())
+    packs = out/'packs'
+    if name == 'prithvi': packs.mkdir(exist_ok=True)
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        while True:
+            chunk=[]
+            for _ in range(CHUNK):
+                try: chunk.append(next(it))
+                except StopIteration: break
+            if not chunk: break
+            part = f'part_{(chunk[0]["id"]-1)//CHUNK:06d}.eoz'
+            tmp = packs/(part+'.partial')
+            stream = tmp.open('wb') if name=='prithvi' else None
+            locations=[]
+            pending_state=json.loads(json.dumps(state))
+            try:
+                results = bounded_map(pool,lambda r:inspect_record(r,source,name,level),chunk,max(2,workers*2))
+                for result in results:
+                    r=result['record']; loc=dict(r['loc'])
+                    loc['source_signatures']=result['signatures']
+                    if stream:
+                        offset=stream.tell(); frame=result['frame']; stream.write(frame)
+                        loc.update(shard=part,offset=offset,length=len(frame))
+                        locations.append((offset,len(frame),result['digest']))
+                        pending_state['packed_bytes']+=len(frame)
+                    for mod,slot,n,moments in result['samples']:
+                        if n:
+                            db.execute('INSERT INTO samples VALUES (?,?,?,?,?)',(mod,r['split'],r['id'],slot,n))
+                            if r['split']=='train': accumulate(pending_state['train_accumulators'][mod],moments)
+                        else:
+                            db.execute('INSERT INTO rejected VALUES (?,?,?,?)',(r['id'],mod,slot,'no_valid_reference_pixels'))
+                    db.execute('INSERT INTO records VALUES (?,?,?,?,?,?,?)',
+                        (r['id'],r['key'],r['split'],r['tile'],json.dumps(result['meta'],separators=(',',':')),
+                         json.dumps(loc,separators=(',',':')),result['digest']))
+                    pending_state['completed_records']+=1
+                    pending_state['raw_bytes']+=result['raw_bytes']
+                if stream:
+                    stream.flush();os.fsync(stream.fileno());stream.close();stream=None
+                    with tmp.open('rb') as check:
+                        for offset,length,digest in locations:
+                            check.seek(offset)
+                            codec.decode(check.read(length),digest)
+                    target = packs/part
+                    tmp.replace(target)
+                    db.execute('INSERT OR REPLACE INTO shards VALUES (?,?,?,?,?)',
+                               (part,target.stat().st_size,sha256_file(target),len(locations),1))
+                pending_state['elapsed_seconds']=prior_time+time.time()-started
+                db.execute('INSERT OR REPLACE INTO settings VALUES (?,?)',('progress',json.dumps(pending_state)))
+                db.commit()
+            except BaseException:
+                if stream:stream.close()
+                db.rollback()
+                raise
+            state=pending_state
+            progress={'dataset':name,'status':'running','phase':'full_preprocessing',
+                      'completed_records':state['completed_records'],'total_records':info['records'],
+                      'raw_GiB':state['raw_bytes']/2**30,'packed_GiB':state['packed_bytes']/2**30,
+                      'elapsed_seconds':state['elapsed_seconds']}
+            json_write(out/'progress.json',progress)
+            if state['completed_records']%(CHUNK*8)==0 or state['completed_records']==info['records']:
+                print(json.dumps(progress),flush=True)
+    if state['completed_records'] != info['records']:raise RuntimeError('Incomplete source census')
+    overlap=db.execute('SELECT tile FROM records GROUP BY tile HAVING COUNT(DISTINCT split)>1 LIMIT 1').fetchone()
+    if overlap:raise ValueError(f'Tile crosses splits within {name}: {overlap[0]}')
+    normalization={mod:finish_stats(acc,mod) for mod,acc in state['train_accumulators'].items()}
+    json_write(out/'normalization.json',normalization)
+    splits={}
+    (out/'indices').mkdir(exist_ok=True)
+    for mod,split,count in db.execute('SELECT modality,split,COUNT(*) FROM samples GROUP BY modality,split').fetchall():
+        path=out/'indices'/f'{split}.{mod}.npy'
+        arr=np.lib.format.open_memmap(path,mode='w+',dtype=np.int64,shape=(count,3))
+        cur=db.execute('SELECT record_id,slot,valid_pixels FROM samples WHERE modality=? AND split=? ORDER BY record_id,slot',(mod,split))
+        pos=0
+        while True:
+            batch=cur.fetchmany(10000)
+            if not batch:break
+            arr[pos:pos+len(batch)]=batch;pos+=len(batch)
+        arr.flush();del arr
+        splits[f'{split}/{mod}']={'samples':count,'index':path.relative_to(out).as_posix(),'sha256':sha256_file(path)}
+    rejected=db.execute('SELECT modality,COUNT(*) FROM rejected GROUP BY modality').fetchall()
+    shards=[dict(zip(['name','bytes','sha256','records','verified'],r)) for r in db.execute('SELECT * FROM shards ORDER BY name')]
+    db.execute('CREATE INDEX IF NOT EXISTS samples_lookup ON samples(modality,split,record_id,slot)')
+    db.commit();db.execute('PRAGMA wal_checkpoint(TRUNCATE)');db.close()
+    artifacts={'index.sqlite':sha256_file(out/'index.sqlite'),'normalization.json':sha256_file(out/'normalization.json'),
+               'source_index.jsonl':info['index_sha256'],'source_info.json':sha256_file(out/'source_info.json'),
+               'protocol.json':sha256_file(out/'protocol.json')}
+    bundle={'version':VERSION,'dataset':name,'status':'ready','scope':'development' if limit else 'full',
+            'backend':'eoz' if name=='prithvi' else 'npz','source_root':info['source_root'],
+            'records':info['records'],'samples':splits,'normalization':'normalization.json','artifacts':artifacts,
+            'identity':identity,'source_manifest_hashes':info['source_manifest_hashes'],
+            'source_bytes':state['raw_bytes'],'packed_bytes':state['packed_bytes'],
+            'shards':shards,'all_packed_records_byte_verified':name=='prithvi',
+            'rejected':dict(rejected),'auxiliary':info['auxiliary'],'elapsed_seconds':state['elapsed_seconds']}
+    json_write(out/'bundle.json',bundle)
+    json_write(out/'progress.json',{'dataset':name,'status':'complete','records':info['records'],
+               'samples':{k:v['samples'] for k,v in splits.items()},'elapsed_seconds':state['elapsed_seconds']})
+    print(f'{name}: COMPLETE {info["records"]} records; '+json.dumps({k:v['samples'] for k,v in splits.items()}),flush=True)
+    return bundle

eo_data/requirements.txt ADDED Viewed

	@@ -0,0 +1,3 @@

+numpy>=1.24
+zstandard>=0.22
+# Optional: torch in the training environment for make_dataloader().

eo_data/verify.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from pathlib import Path
+import io
+import json
+import shutil
+import sqlite3
+import time
+import numpy as np
+from . import codec
+from .core import canonical, dataset_name, json_write, sha256_file
+from .dataset import open_dataset
+def verify_all(root,output=None,dataset='all',samples=16,allow_development=False):
+    root=Path(root).resolve();output=Path(output or root/'processed_data/v1')
+    names=['prithvi','lstsr_tb'] if dataset=='all' else [dataset_name(dataset)]
+    report={}
+    for name in names:
+        directory=output/name
+        bundle=json.loads((directory/'bundle.json').read_text(encoding='utf-8'))
+        checked={};started=time.perf_counter()
+        for key,entry in bundle['samples'].items():
+            split,mod=key.split('/')
+            ds=open_dataset(name,mod,split,root=root,prepared=output,allow_development=allow_development)
+            indices=np.unique(np.linspace(0,len(ds)-1,min(samples,len(ds)),dtype=int))
+            for index in indices:
+                item=ds[int(index)]
+                image=item['image'];mask=item['reference_mask']
+                assert image.shape==((6,256,256) if mod=='hls' else (1,256,256))
+                assert image.dtype==np.float32 and mask.dtype==bool
+                assert np.isfinite(image).all() and np.array_equal(image,item['target'])
+                assert not np.shares_memory(image,item['target'])
+                assert (image[~np.broadcast_to(mask,image.shape)]==0).all()
+                _,_,slot,_,row=ds._record(int(index));loc=json.loads(row[3])
+                if name=='prithvi':
+                    parts=ds._parts(loc,row[4])
+                    raw=np.load(io.BytesIO(parts[0 if mod=='hls' else 2]),allow_pickle=False)
+                    f=np.load(io.BytesIO(parts[1]),allow_pickle=False) if mod=='hls' else None
+                    reference,rmask=canonical(raw,mod,name,fmask=f)
+                    original=ds.source/loc['path']
+                    if original.exists():
+                        for base,payload in zip(codec.FILENAMES,parts):
+                            if (original/base).read_bytes()!=payload:raise ValueError('Original/packed byte mismatch')
+                elif mod=='hls':
+                    raw,f,v=ds._npz(loc);reference,rmask=canonical(raw,mod,name,fmask=f,source_valid=v)
+                else:
+                    raw,v=ds._npz(loc);reference,rmask=canonical(raw[slot],mod,name,source_valid=v[slot])
+                assert np.array_equal(mask,rmask)
+                valid=np.broadcast_to(mask,reference.shape)
+                tolerance=2e-6 if mod=='hls' else 0.005
+                if not np.allclose(ds.denormalize(image)[valid],reference[valid],rtol=0,atol=tolerance):
+                    raise ValueError('Normalization round trip failed')
+            checked[key]={'samples':len(ds),'checked':len(indices),'roundtrip_passed':True}
+            ds.close()
+        report[name]={'status':'passed','scope':bundle['scope'],'profiles':checked,
+                      'all_compressed_records_verified_during_preparation':bundle['all_packed_records_byte_verified'],
+                      'seconds':time.perf_counter()-started}
+        json_write(directory/'verification.json',report[name])
+    return report
+def restore_prithvi(root,prepared,destination,limit=None):
+    root=Path(root).resolve();directory=Path(prepared or root/'processed_data/v1')/'prithvi'
+    destination=Path(destination).resolve()
+    if destination.exists() and any(destination.iterdir()):
+        raise ValueError('Restore destination must be absent or empty')
+    destination.mkdir(parents=True,exist_ok=True)
+    bundle=json.loads((directory/'bundle.json').read_text(encoding='utf-8'))
+    reader=open_dataset('prithvi','hls',root=root,prepared=directory.parent,allow_development=True)
+    db=reader._connect()
+    n=0
+    for key,loc_text,digest in db.execute('SELECT key,loc,digest FROM records ORDER BY id'):
+        loc=json.loads(loc_text)
+        parts=reader._parts(loc,digest)
+        folder=(destination/key).resolve()
+        if not folder.is_relative_to(destination):raise ValueError('Unsafe restored path')
+        folder.mkdir(parents=True,exist_ok=True)
+        for base,payload in zip(codec.FILENAMES,parts):(folder/base).write_bytes(payload)
+        n+=1
+        if limit and n>=limit:break
+    reader.close()
+    for rel,info in bundle['auxiliary'].items():
+        src=directory/'original_aux'/rel;dst=(destination/rel).resolve()
+        if not dst.is_relative_to(destination):raise ValueError('Unsafe auxiliary path')
+        if sha256_file(src)!=info['sha256']:raise ValueError('Auxiliary hash mismatch')
+        dst.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(src,dst)
+    return {'restored_records':n,'full_dataset':n==bundle['records'],'destination':str(destination)}

experiments/data/LST_ENCODING_VERIFICATION.md ADDED Viewed

	@@ -0,0 +1,56 @@

+# LST 存储单位核验
+2026-09-13来源补充：用户现已提供第一套HLP的下载代码，确认其使用HLSL30 v2与Landsat 8/9 Collection 2 Level-2 `ST_B10`，并在导出时转换为摄氏度×100。下文“未找到原始导出代码”描述的是本次单位抽样核验当时的材料范围；现状与实现细节见[下载来源核对](../../data_inspection/HLP_SOURCE_PROVENANCE.md)。此补充不改变原抽样结果，也不宣称已取得每个历史样本的LST贡献场景ID。第二套HLC的完整导出代码仍未由此次材料补齐。
+结论：两套数据当前用于 VAE 的 HR LST 支持按 **摄氏度 × 100** 的整数编码解释，恢复摄氏度使用 `stored / 100.0`。这次结论有原始卫星像元对照证据，超出了只凭数值范围猜测的阶段。
+## 独立验证方法与范围
+- Prithvi 全部 242,416 条 metadata 的 `lst_scale` 都是 100。选择 HLS ID 与目标 tile 一致、行列为 r00_c00 的两个 patch，用同 tile 的已交付网格计算像元中心，不通过拟合偏移改变坐标。每个 patch 预先固定 3×3 个位置，共 18 个。
+- Prithvi metadata 没有记录 LST 场景 ID。首先由 HLS 时间寻找 Landsat 场景；第二个 patch 的该场景在所有检查点都无 ST 值，于是检查同日、同卫星、同轨道的相邻 WRS 行。保留初始无值响应及后续结果。这个过程提供独立数值佐证，不等于从 metadata 直接确认了完整 LST 来源链。
+- LSTSR 使用 manifest 明确给出的网格、patch 偏移和 Landsat 场景列表。检查 `T01WCP_v000_p0000` 的 4 月、8 月槽位，分别对应 2024-04-06 和 2022-08-08；每月预先固定相同 3×3 个位置。缺失场景与无效原始像元均保留在记录中。
+- 从 Microsoft Planetary Computer 的公开 Landsat Collection 2 ST 波段读取原始 DN，`unscale=false`；自行应用 `DN * 0.00341802 + 149.0 - 273.15`，与本地存储值除以 100 的结果比较。公式依据 [USGS 官方说明](https://www.usgs.gov/landsat-missions/landsat-collection-2-surface-temperature)。
+| 数据 | 预选有效位置 | 能取得源 DN 的位置 | 差异 ≤0.011°C | 差异 ≤0.02°C | 最大绝对差 |
+|---|---:|---:|---:|---:|---:|
+| Prithvi，2 个 patch | 18 | 18 | 17 | 18 | 0.015749°C |
+| LSTSR，2 个 patch-month | 18 | 17 | 17 | 17 | 0.004857°C |
+0.011°C 检查约一个存储整数步长，0.02°C 用于容纳很小的插值/量化差异、判断单位是否一致。Prithvi 有一个位置超过前者，原因未从导出代码核实，不能报告为逐位一致。LSTSR 有一个位置未取得原始值；公开镜像中 `LC08_L2SP_091013_20220808_02_T1` 返回 404。原始导出代码未在当前交付工作区找到；这里是单位的抽样核验，不能替代全量来源一致性证明。
+两个直观例子：
+| 数据与位置 | 本地存储值 | 除以 100 | 原始 Landsat DN | 按 USGS 公式换算 |
+|---|---:|---:|---:|---:|
+| Prithvi `T03VXK/obs_0014/r00_c00`，像元 `[128,128]` | -2028 | -20.28°C | 30387 | -20.286626°C |
+| LSTSR `T01WCP_v000_p0000`，4 月 `[128,128]` | -868 | -8.68°C | 33782 | -8.682448°C |
+## 其他证据
+两套数据已冻结的训练集样本等权均值分别为 2539.23749、2709.74793 个存储单位；除以 100 后分别为 25.39237°C 和 27.09748°C。这只是单位解释的辅助证据，不用于单独证明单位。
+LSTSR 的 LR 来自 MODIS/061/MOD11A1，其原始温度比例是 0.02 K/DN，见 [官方数据目录](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MOD11A1)。既有 2,560 个 sequence 的确定性样本中，1,693,306 个有效 LR 像元的整数值全部是奇数，正好符合 `100 * (0.02 * MODIS_DN - 273.15) = 2 * MODIS_DN - 27315` 的量化特征。它支持 LR 同样保存为摄氏度 × 100，但当前训练范围仅为 HR；不要把 Landsat 原始 DN 公式用于 MODIS。
+## 当前统一接口如何用
+```python
+import numpy as np
+from eo_data import open_dataset
+ds = open_dataset('prithvi', 'lst', 'train')  # 另一套使用 'lstsr_tb'
+sample = ds[0]
+temperature_c = ds.denormalize(sample['image']) / 100.0
+temperature_c = np.where(sample['reference_mask'], temperature_c, np.nan)
+```
+`image` 已是 z-score，不能直接除以 100 当温度；无效位置也要保持 mask。当前 `denormalize()` 返回存储编码值。v1 文件和代码没有在这次单位核验中更改，冻结统计中的未知单位标志是构建时的历史状态。
+物理单位恢复与训练标准化分开解释：将存储值、训练均值和标准差同时除以 100，z-score 不变。因此不需要重跑全量处理。物理温度 MAE/RMSE 为存储单位误差除以 100，MSE 除以 10000；沿用原来的有效像元与样本权重。
+## 复查入口
+- [检查脚本](check_lst_encoding.py)：读取原文件、已冻结统计及公开原始场景，输出逐点结果。
+- [逐点结果 JSON](lst_encoding_verification.json)：含请求参数、原始响应、场景 ID、源文件 SHA-256、失败记录与分母。
+- [检查 notebook](lst_encoding_verification.ipynb)：展示结果，并提供重新运行同一检查的入口。
+在工作区运行 `python experiments/data/check_lst_encoding.py` 即可重做检查。公开数据服务的未来变化可能导致来源不可用，失败会保留在结果中。

experiments/data/dataset_catalog.json ADDED Viewed

	@@ -0,0 +1,167 @@

+{
+  "schema_version": 1,
+  "updated": "2026-09-30",
+  "source_document": "data_inspection/FINAL_DATASET_SUMMARY.md",
+  "scope": "Current dataset working names and versioned split metadata; original source storage and legacy v1 remain unchanged.",
+  "terms": {
+    "hr": "fine-resolution LST",
+    "lr": "coarse-resolution LST",
+    "sequence_id": "calendar-month bundle identifier (HLC)",
+    "fine_lst_role": "satellite-retrieved reference product",
+    "temperature_decode": "stored / 100.0 (degrees Celsius); mask invalid values first",
+    "reader_temperature_decode": "ds.denormalize(sample['image']) / 100.0; use reference_mask",
+    "resolution_ratio": "256 / 8 = 32 is the array side-length ratio, not independent thermal information gain"
+  },
+  "datasets": [
+    {
+      "name": "HLS-LST-Pairs",
+      "short_name": "HLP",
+      "reader_id": "prithvi",
+      "legacy_names": [
+        "Prithvi Data",
+        "prithvi_data"
+      ],
+      "record_unit": "HLS/fine LST patch pair",
+      "records": 242416,
+      "mgrs_tiles": 3094,
+      "hls_samples": 242416,
+      "fine_lst_samples": 242416,
+      "splits": {
+        "train": {
+          "reader_split": "train",
+          "tiles": 2796,
+          "hls_samples": 218975,
+          "fine_lst_samples": 218975
+        },
+        "validation": {
+          "reader_split": "val",
+          "tiles": 147,
+          "hls_samples": 11684,
+          "fine_lst_samples": 11684
+        },
+        "test": {
+          "reader_split": "test",
+          "tiles": 151,
+          "hls_samples": 11757,
+          "fine_lst_samples": 11757
+        }
+      },
+      "storage": {
+        "kind": "zip64_eoz",
+        "path": "artifacts/prithvi_data_v1_20260909.zip"
+      },
+      "prepared_directory": "processed_data/hlp_split_v2_20260914/prithvi",
+      "coarse_lst": "not delivered; synthetic degradation required",
+      "continuous_time_series": false,
+      "legacy_prepared_directory": "processed_data/v1/prithvi",
+      "legacy_split_mapping": {
+        "train": "train",
+        "test": "val"
+      },
+      "reader_prepared_argument": "processed_data/hlp_split_v2_20260914",
+      "split_version": "hlp-tile-validation-v2-20260914",
+      "split_summary": "data_inspection/hlp_split_20260914/split_summary.json"
+    },
+    {
+      "name": "HLS-LST-CrossSensor",
+      "short_name": "HLC",
+      "reader_id": "lstsr_tb",
+      "legacy_names": [
+        "LSTSR-TB",
+        "LSTSR",
+        "lstsr_tb_final_upload_20260721"
+      ],
+      "record_unit": "calendar-month bundle",
+      "records": 277808,
+      "mgrs_tiles": 2490,
+      "hls_samples": 277808,
+      "fine_lst_samples": 2892007,
+      "splits": {
+        "train": {
+          "reader_split": "train",
+          "hls_samples": 250449,
+          "fine_lst_samples": 2608772
+        },
+        "validation": {
+          "reader_split": "val",
+          "hls_samples": 13694,
+          "fine_lst_samples": 141711
+        },
+        "test": {
+          "reader_split": "test",
+          "hls_samples": 13665,
+          "fine_lst_samples": 141524
+        }
+      },
+      "storage": {
+        "kind": "npz_directory",
+        "path": "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719"
+      },
+      "prepared_directory": "processed_data/v1/lstsr_tb",
+      "coarse_lst": "Terra/MODIS MOD11A1 Collection 6.1; actual same-calendar-day coarse/fine pairs",
+      "continuous_time_series": false,
+      "full_membership_experiments": [
+        {
+          "run_id": "hlc-synthetic-full-epoch1-ddp2-io16-20260916-v3",
+          "manifest": "experiments/efdiff_hlc/deadline_run_manifest.json",
+          "train_fine_lst_months": 2608772,
+          "epochs": 1,
+          "val_fine_lst_months": 512,
+          "test_used": false,
+          "input": "synthetic Wald32 coarse LST and associated HLS",
+          "split_membership_unchanged": true,
+          "status": "complete; each model 2608772 records, 40763 updates, one epoch; 24-hour deadline met",
+          "world_size_per_model": 2,
+          "deadline_utc": "2026-09-18T04:23:04Z",
+          "loader_workers_per_rank": 16,
+          "local_full_test": {
+            "status": "launched; see run manifest and live pipeline",
+            "records": 141524,
+            "crop": 224,
+            "checkpoint": "fixed_epoch1_ema",
+            "test_used_for_selection": false,
+            "manifest": "experiments/efdiff_hlc/deadline_run_manifest.json",
+            "live_pipeline": "output/efdiff_hlc_epoch1_deadline_io16_20260916/full_test_20260921/pipeline.json"
+          }
+        },
+        {
+          "run_id": "hlc-synthetic-full-epoch1-20260916-v1",
+          "manifest": "experiments/efdiff_hlc/epoch1_run_manifest.json",
+          "train_fine_lst_months": 2608772,
+          "epochs": 1,
+          "val_fine_lst_months": 512,
+          "test_used": false,
+          "input": "synthetic Wald32 coarse LST and associated HLS",
+          "split_membership_unchanged": true,
+          "status": "preparation superseded by deadline DDP2 run; statistics retained"
+        }
+      ],
+      "experimental_subsets": [
+        {
+          "version": "efdiff-hlc-synthetic-pilot-16384-512-v1",
+          "scope": "experiment-only fixed subset; original splits unchanged",
+          "summary": "experiments/efdiff_hlc/pilot_membership/summary.json",
+          "manifest": "experiments/efdiff_hlc/pilot_run_manifest.json",
+          "train_fine_lst_months": 16384,
+          "val_fine_lst_months": 512,
+          "test_used": false,
+          "input": "synthetic Wald32 coarse LST and associated HLS; no actual MODIS input"
+        }
+      ],
+      "new_experiment_spatial_protocol": {
+        "protocol": "efdiff-hlc-fixed-center224-no-flip-20260930-v1",
+        "definition": "experiments/efdiff_hlc/center_crop_protocol.json",
+        "scope": "New synthetic-degradation experiments only; original data, splits and frozen historical training unchanged",
+        "shared_across_sequence_months": true,
+        "shared_across_epochs": true,
+        "crop": [
+          16,
+          240,
+          16,
+          240
+        ],
+        "random_flip": false
+      }
+    }
+  ]
+}

experiments/data/protocol.json ADDED Viewed

	@@ -0,0 +1,82 @@

+{
+  "protocol_id": "eo-independent-reconstruction-v1",
+  "status": "defined_not_materialized",
+  "training_scope": "independent_datasets",
+  "shared_processing_policy": {
+    "modalities": ["hls", "lst_hr"],
+    "shape": {"hls": [6, 256, 256], "lst_hr": [1, 256, 256]},
+    "dtype": "float32",
+    "hls_band_order": ["Blue", "Green", "Red", "NIR", "SWIR1", "SWIR2"],
+    "hls_fmask_fill": 255,
+    "hls_bad_fmask_bits": 14,
+    "hls_mask_rule": "source_valid AND all_bands_not_fill AND fmask!=255 AND (fmask&14)==0",
+    "lst_mask_rule": "source_valid_if_present AND raw_not_source_fill",
+    "remove_zero_as_nodata": false,
+    "extra_snow_water_aerosol_exclusion": false,
+    "normalization": {
+      "method": "fixed_zscore",
+      "fit_split": "train",
+      "parameter_scope": ["dataset_id", "modality", "split_hash"],
+      "hls": "per_band",
+      "lst_hr": "one_channel_global",
+      "weighting": "equal_training_samples_and_equal_valid_pixels_within_each_sample",
+      "per_image_fitting": false,
+      "clip": false,
+      "invalid_fill_after_normalization": 0.0,
+      "train_only": true,
+      "physical_unit_required_for_physical_metrics": true
+    },
+    "augmentation": {"geometric": false, "synthetic_noise": false},
+    "sampling": "uniform_shuffle_over_eligible_modality_samples",
+    "hls_repeat_per_lst_month_for_independent_training": false,
+    "model_specific_resizing_or_normalization": false,
+    "prithvi_time_dimension": "length_one_layout_only",
+    "loss_reduction": "mean_of_per_sample_valid_element_means",
+    "all_invalid_sample": "exclude_for_that_modality_and_log",
+    "expose_provenance_to_model_automatically": false
+  },
+  "datasets": {
+    "prithvi": {
+      "root": "prithvi_data",
+      "index_source": "actual_file_inventory",
+      "sample_key": ["source_split", "tile", "obs_idx", "row", "col"],
+      "splits": ["train", "val"],
+      "hls_array": "bands.npy",
+      "hls_fmask": "fmask.npy",
+      "hls_scale": 0.0001,
+      "hls_fill_candidates": [-9999, -32767, -32768],
+      "lst_hr_array": "lst.npy",
+      "lst_observed_fill": -32767,
+      "lst_recorded_scale_divisor": 100,
+      "lst_physical_unit": null,
+      "lst_baseline_statistics_space": "raw_int16_as_float_until_physical_decode_confirmed"
+    },
+    "lstsr_tb": {
+      "upload_root": "lstsr_tb_final_upload_20260721",
+      "root": "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719",
+      "index_source": "phase4_dataset_manifest.csv",
+      "hls_manifest": "hls_l8_conditions_2019_2025_lc08/hls_condition_manifest.csv",
+      "splits": ["train", "val", "test"],
+      "hls_sample_key": ["sequence_id"],
+      "lst_hr_sample_key": ["sequence_id", "available_month"],
+      "hls_array_key": "hls_reflectance_i16",
+      "hls_valid_key": "hls_valid",
+      "hls_fmask_key": "hls_fmask",
+      "hls_scale": 0.0001,
+      "hls_nodata": -32768,
+      "lst_hr_array_key": "hr_lst",
+      "lst_hr_valid_key": "hr_valid",
+      "lst_nodata": -32768,
+      "lst_physical_unit": null,
+      "lst_baseline_statistics_space": "raw_int16_as_float_until_physical_decode_confirmed",
+      "availability_rule": "manifest_available_months_AND_nonempty_hr_valid",
+      "require_complete_twelve_months": false,
+      "lst_lr_in_current_baseline": false
+    }
+  },
+  "normalization_profiles": ["prithvi/hls", "prithvi/lst_hr", "lstsr_tb/hls", "lstsr_tb/lst_hr"],
+  "model_architectures_per_profile": ["vae", "prithvi_architecture_vae"],
+  "run_count": 8,
+  "frozen_normalization_files": [],
+  "training_started": false
+}

experiments/efdiff_hlc/center_crop_protocol.json ADDED Viewed

	@@ -0,0 +1,20 @@

+{
+  "protocol": "efdiff-hlc-fixed-center224-no-flip-20260930-v1",
+  "scope": "New HLC synthetic-degradation experiments; frozen historical runs unchanged",
+  "dataset": "HLS-LST-CrossSensor",
+  "prepared": "processed_data/v1",
+  "loader": "experiments/efdiff_hlc/center_data.py:HLCPairs",
+  "loader_arguments": {"augment": false},
+  "source_size": [256, 256],
+  "crop_size": [224, 224],
+  "row_slice": [16, 240],
+  "column_slice": [16, 240],
+  "shared_across_sequence_months": true,
+  "shared_across_epochs": true,
+  "random_flip": false,
+  "modalities": ["fine LST", "HLS", "mask"],
+  "synthetic_coarse": "Wald x32 degradation after the shared crop",
+  "normalization": "Reuse verified historical full-train center-crop statistics with their original provenance; center_data.check_stats validates them",
+  "new_run_requirements": ["Import center_data.HLCPairs and center_data.check_stats", "Pass augment=False", "Record protocol and center_data.py hash in provenance and checkpoint compatibility checks", "Use a new run ID; do not resume historical random-crop checkpoints as a controlled fresh comparison"],
+  "launch_status": "loader prepared; no new training launched"
+}

processed_data/v1/lstsr_tb/bundle.json ADDED Viewed

	@@ -0,0 +1,75 @@

+{
+  "version": "eo-independent-reconstruction-v1",
+  "dataset": "lstsr_tb",
+  "status": "ready",
+  "scope": "full",
+  "backend": "npz",
+  "source_root": "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719",
+  "records": 277808,
+  "samples": {
+    "test/hls": {
+      "samples": 13665,
+      "index": "indices/test.hls.npy",
+      "sha256": "0b9e21fa5139109f5ac6fd8e0c9f3b752b7e471eadb34c9520e891a2a4b755b6"
+    },
+    "train/hls": {
+      "samples": 250449,
+      "index": "indices/train.hls.npy",
+      "sha256": "cabbca0e1424f84893efa138d0ca6e4dd397c22dd335525bd32a8281ae3f3500"
+    },
+    "val/hls": {
+      "samples": 13694,
+      "index": "indices/val.hls.npy",
+      "sha256": "d3cc1361a9ff55b3ccf4cb50c39a437eeaa360ebcf93e8f504e7d293a2bad0b6"
+    },
+    "test/lst_hr": {
+      "samples": 141524,
+      "index": "indices/test.lst_hr.npy",
+      "sha256": "4a94702e7b45c680e144a6b8f81cad51a394fa33369cea07db5f9f1c631b76f0"
+    },
+    "train/lst_hr": {
+      "samples": 2608772,
+      "index": "indices/train.lst_hr.npy",
+      "sha256": "e1a76a84b8872caab5a8a2a6494b08b67891943677ec3c9f007fab02d29f6715"
+    },
+    "val/lst_hr": {
+      "samples": 141711,
+      "index": "indices/val.lst_hr.npy",
+      "sha256": "855e7a933dafbc400be01e98912c352aa02133c1f72e5ef5921b0a9b6daace78"
+    }
+  },
+  "normalization": "normalization.json",
+  "artifacts": {
+    "index.sqlite": "9a256c2395174cd3e53f8cfaf57b6ccac3cf187f161eeb5303d51c805a920f82",
+    "normalization.json": "4d19c9c4ec24f5e9bc38ad5a7f466881d8da57e2cec5750f3751df08cb39a260",
+    "source_index.jsonl": "320cba48e59dd201c2ec2763bc33fffec5ab31488458fdf1e993090bcc292a3e",
+    "source_info.json": "463de81163ea3e7b2a9249cc304f4edbb4e4cab42e9bf6756ec02c01d6f67d5e",
+    "protocol.json": "986e5c3210bf3d2e54c9eccedc0775c4724ab475e1bb98ef893d65befe5a3bc8"
+  },
+  "identity": {
+    "protocol_sha256": "b3f6a94d26cfa021334aca031fe445ee7a80dcbe911e17a3728e1b77c025a98d",
+    "pipeline_sha256": {
+      "codec.py": "7e3f21ca95652919dd69d26b5f448af7da8af7c47a836e900f4c6b01ba340dff",
+      "core.py": "7b56ddaa8d037a7acab3fb1f17ea1e294bc21d69187a0efbc43735dbe0d0c513",
+      "dataset.py": "c335ab2975f019eccbeefab4b7c443e49867c592169f0c4b0f09be101360af84",
+      "prepare.py": "9ba7e9277088591696de88f9ce1b739e23b3b15729d8ea2fab03dc3ddc66c378",
+      "verify.py": "0980a434089637c9eb702be95568302589d1786c4aaabe4b8d216442eb772e2f",
+      "__init__.py": "b89c5939d137e74d81e82fa90d01f085d3d62d498f380b18770e1e8b42d99b58",
+      "__main__.py": "7d8ef47df0580c754b3d581e4024a0924a7e3abd8fb4c67f9cb53fb63aa7a058"
+    },
+    "source_index_sha256": "320cba48e59dd201c2ec2763bc33fffec5ab31488458fdf1e993090bcc292a3e",
+    "zstd_level": 3,
+    "limit": null
+  },
+  "source_manifest_hashes": {
+    "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/phase4_dataset_manifest.csv": "7110aca1ec7ef1d55b3098686e98139d9230577734d45863468a5622af0c253c",
+    "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/hls_l8_conditions_2019_2025_lc08/hls_condition_manifest.csv": "08d8d48d45e592b7e27994bcbc8835c8d493f08cef1f1c851c2d553e602da946"
+  },
+  "source_bytes": 432655059412,
+  "packed_bytes": 0,
+  "shards": [],
+  "all_packed_records_byte_verified": false,
+  "rejected": {},
+  "auxiliary": {},
+  "elapsed_seconds": 2844.987811088562
+}

processed_data/v1/lstsr_tb/index.sqlite ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:9a256c2395174cd3e53f8cfaf57b6ccac3cf187f161eeb5303d51c805a920f82
+size 538554368

processed_data/v1/lstsr_tb/indices/test.hls.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0b9e21fa5139109f5ac6fd8e0c9f3b752b7e471eadb34c9520e891a2a4b755b6
+size 328088

processed_data/v1/lstsr_tb/indices/test.lst_hr.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:4a94702e7b45c680e144a6b8f81cad51a394fa33369cea07db5f9f1c631b76f0
+size 3396704

processed_data/v1/lstsr_tb/indices/train.hls.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:cabbca0e1424f84893efa138d0ca6e4dd397c22dd335525bd32a8281ae3f3500
+size 6010904

processed_data/v1/lstsr_tb/indices/train.lst_hr.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a76a84b8872caab5a8a2a6494b08b67891943677ec3c9f007fab02d29f6715
+size 62610656

processed_data/v1/lstsr_tb/indices/val.hls.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d3cc1361a9ff55b3ccf4cb50c39a437eeaa360ebcf93e8f504e7d293a2bad0b6
+size 328784

processed_data/v1/lstsr_tb/indices/val.lst_hr.npy ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:855e7a933dafbc400be01e98912c352aa02133c1f72e5ef5921b0a9b6daace78
+size 3401192

processed_data/v1/lstsr_tb/normalization.json ADDED Viewed

	@@ -0,0 +1,53 @@

+{
+  "hls": {
+    "mean": [
+      0.06004754034145592,
+      0.09453229605916574,
+      0.10980806300230178,
+      0.2747008017865311,
+      0.24341935169315215,
+      0.17196968451789005
+    ],
+    "std": [
+      0.0680510125621377,
+      0.07543071016089009,
+      0.09833689281963476,
+      0.10047386303401144,
+      0.12207512634543984,
+      0.11687593558796062
+    ],
+    "unfloored_std": [
+      0.0680510125621377,
+      0.07543071016089009,
+      0.09833689281963476,
+      0.10047386303401144,
+      0.12207512634543984,
+      0.11687593558796062
+    ],
+    "std_floor": 1e-06,
+    "samples": 250449,
+    "valid_spatial_pixels": 16399726473,
+    "fit_split": "train",
+    "weighting": "equal_samples_then_equal_valid_pixels_within_sample",
+    "units": "reflectance",
+    "physical_temperature_unit_confirmed": null
+  },
+  "lst_hr": {
+    "mean": [
+      2709.747934379476
+    ],
+    "std": [
+      1671.9957488981986
+    ],
+    "unfloored_std": [
+      1671.9957488981986
+    ],
+    "std_floor": 1e-06,
+    "samples": 2608772,
+    "valid_spatial_pixels": 170188681574,
+    "fit_split": "train",
+    "weighting": "equal_samples_then_equal_valid_pixels_within_sample",
+    "units": "source_raw_int16_units",
+    "physical_temperature_unit_confirmed": false
+  }
+}

processed_data/v1/lstsr_tb/progress.json ADDED Viewed

	@@ -0,0 +1,14 @@

+{
+  "dataset": "lstsr_tb",
+  "status": "complete",
+  "records": 277808,
+  "samples": {
+    "test/hls": 13665,
+    "train/hls": 250449,
+    "val/hls": 13694,
+    "test/lst_hr": 141524,
+    "train/lst_hr": 2608772,
+    "val/lst_hr": 141711
+  },
+  "elapsed_seconds": 2844.987811088562
+}

processed_data/v1/lstsr_tb/protocol.json ADDED Viewed

	@@ -0,0 +1,140 @@

+{
+  "protocol_id": "eo-independent-reconstruction-v1",
+  "status": "defined_not_materialized",
+  "training_scope": "independent_datasets",
+  "shared_processing_policy": {
+    "modalities": [
+      "hls",
+      "lst_hr"
+    ],
+    "shape": {
+      "hls": [
+        6,
+        256,
+        256
+      ],
+      "lst_hr": [
+        1,
+        256,
+        256
+      ]
+    },
+    "dtype": "float32",
+    "hls_band_order": [
+      "Blue",
+      "Green",
+      "Red",
+      "NIR",
+      "SWIR1",
+      "SWIR2"
+    ],
+    "hls_fmask_fill": 255,
+    "hls_bad_fmask_bits": 14,
+    "hls_mask_rule": "source_valid AND all_bands_not_fill AND fmask!=255 AND (fmask&14)==0",
+    "lst_mask_rule": "source_valid_if_present AND raw_not_source_fill",
+    "remove_zero_as_nodata": false,
+    "extra_snow_water_aerosol_exclusion": false,
+    "normalization": {
+      "method": "fixed_zscore",
+      "fit_split": "train",
+      "parameter_scope": [
+        "dataset_id",
+        "modality",
+        "split_hash"
+      ],
+      "hls": "per_band",
+      "lst_hr": "one_channel_global",
+      "weighting": "equal_training_samples_and_equal_valid_pixels_within_each_sample",
+      "per_image_fitting": false,
+      "clip": false,
+      "invalid_fill_after_normalization": 0.0,
+      "train_only": true,
+      "physical_unit_required_for_physical_metrics": true
+    },
+    "augmentation": {
+      "geometric": false,
+      "synthetic_noise": false
+    },
+    "sampling": "uniform_shuffle_over_eligible_modality_samples",
+    "hls_repeat_per_lst_month_for_independent_training": false,
+    "model_specific_resizing_or_normalization": false,
+    "prithvi_time_dimension": "length_one_layout_only",
+    "loss_reduction": "mean_of_per_sample_valid_element_means",
+    "all_invalid_sample": "exclude_for_that_modality_and_log",
+    "expose_provenance_to_model_automatically": false
+  },
+  "datasets": {
+    "prithvi": {
+      "root": "prithvi_data",
+      "index_source": "actual_file_inventory",
+      "sample_key": [
+        "source_split",
+        "tile",
+        "obs_idx",
+        "row",
+        "col"
+      ],
+      "splits": [
+        "train",
+        "val"
+      ],
+      "hls_array": "bands.npy",
+      "hls_fmask": "fmask.npy",
+      "hls_scale": 0.0001,
+      "hls_fill_candidates": [
+        -9999,
+        -32767,
+        -32768
+      ],
+      "lst_hr_array": "lst.npy",
+      "lst_observed_fill": -32767,
+      "lst_recorded_scale_divisor": 100,
+      "lst_physical_unit": null,
+      "lst_baseline_statistics_space": "raw_int16_as_float_until_physical_decode_confirmed"
+    },
+    "lstsr_tb": {
+      "upload_root": "lstsr_tb_final_upload_20260721",
+      "root": "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719",
+      "index_source": "phase4_dataset_manifest.csv",
+      "hls_manifest": "hls_l8_conditions_2019_2025_lc08/hls_condition_manifest.csv",
+      "splits": [
+        "train",
+        "val",
+        "test"
+      ],
+      "hls_sample_key": [
+        "sequence_id"
+      ],
+      "lst_hr_sample_key": [
+        "sequence_id",
+        "available_month"
+      ],
+      "hls_array_key": "hls_reflectance_i16",
+      "hls_valid_key": "hls_valid",
+      "hls_fmask_key": "hls_fmask",
+      "hls_scale": 0.0001,
+      "hls_nodata": -32768,
+      "lst_hr_array_key": "hr_lst",
+      "lst_hr_valid_key": "hr_valid",
+      "lst_nodata": -32768,
+      "lst_physical_unit": null,
+      "lst_baseline_statistics_space": "raw_int16_as_float_until_physical_decode_confirmed",
+      "availability_rule": "manifest_available_months_AND_nonempty_hr_valid",
+      "require_complete_twelve_months": false,
+      "lst_lr_in_current_baseline": false
+    }
+  },
+  "normalization_profiles": [
+    "prithvi/hls",
+    "prithvi/lst_hr",
+    "lstsr_tb/hls",
+    "lstsr_tb/lst_hr"
+  ],
+  "model_architectures_per_profile": [
+    "vae",
+    "prithvi_architecture_vae"
+  ],
+  "run_count": 8,
+  "frozen_normalization_files": [],
+  "training_started": false
+}

processed_data/v1/lstsr_tb/source_index.jsonl ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:320cba48e59dd201c2ec2763bc33fffec5ab31488458fdf1e993090bcc292a3e
+size 185447541

processed_data/v1/lstsr_tb/source_info.json ADDED Viewed

	@@ -0,0 +1,25 @@

+{
+  "dataset": "lstsr_tb",
+  "source_root": "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719",
+  "records": 277808,
+  "record_counts": {
+    "train": 250449,
+    "test": 13665,
+    "val": 13694
+  },
+  "candidate_samples": {
+    "train/hls": 250449,
+    "train/lst_hr": 2608772,
+    "test/hls": 13665,
+    "test/lst_hr": 141524,
+    "val/hls": 13694,
+    "val/lst_hr": 141711
+  },
+  "source_manifest_hashes": {
+    "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/phase4_dataset_manifest.csv": "7110aca1ec7ef1d55b3098686e98139d9230577734d45863468a5622af0c253c",
+    "data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719/hls_l8_conditions_2019_2025_lc08/hls_condition_manifest.csv": "08d8d48d45e592b7e27994bcbc8835c8d493f08cef1f1c851c2d553e602da946"
+  },
+  "index_sha256": "320cba48e59dd201c2ec2763bc33fffec5ab31488458fdf1e993090bcc292a3e",
+  "auxiliary": {},
+  "limit": null
+}

processed_data/v1/lstsr_tb/verification.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "status": "passed",
+  "scope": "full",
+  "profiles": {
+    "test/hls": {
+      "samples": 13665,
+      "checked": 32,
+      "roundtrip_passed": true
+    },
+    "train/hls": {
+      "samples": 250449,
+      "checked": 32,
+      "roundtrip_passed": true
+    },
+    "val/hls": {
+      "samples": 13694,
+      "checked": 32,
+      "roundtrip_passed": true
+    },
+    "test/lst_hr": {
+      "samples": 141524,
+      "checked": 32,
+      "roundtrip_passed": true
+    },
+    "train/lst_hr": {
+      "samples": 2608772,
+      "checked": 32,
+      "roundtrip_passed": true
+    },
+    "val/lst_hr": {
+      "samples": 141711,
+      "checked": 32,
+      "roundtrip_passed": true
+    }
+  },
+  "all_compressed_records_verified_during_preparation": false,
+  "seconds": 2.1120287000012468
+}

release.json ADDED Viewed

The diff for this file is too large to render. See raw diff

scripts/restore.py ADDED Viewed

	@@ -0,0 +1,92 @@

+"""Restore a versioned HLP/HLC Hub snapshot without changing frozen indices."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import tarfile
+def safe_path(root, relative):
+    path = (root / relative).resolve()
+    if not path.is_relative_to(root.resolve()):
+        raise ValueError(f"Path outside snapshot: {relative}")
+    return path
+def digest(path):
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        for block in iter(lambda: f.read(8 * 1024**2), b''):
+            h.update(block)
+    return h.hexdigest()
+def restore(root):
+    root = root.resolve()
+    release = json.loads((root / 'release.json').read_text(encoding='utf-8'))
+    # Validate manifests and reader/indices before trusting their restoration instructions.
+    for item in release['files']:
+        path = safe_path(root, item['path'])
+        if not path.is_file() or path.stat().st_size != item['size']:
+            raise ValueError(f"Missing or truncated file: {path}")
+        if item['path'].startswith('data/'):
+            continue  # Every extracted byte is verified below against the member manifest.
+        if digest(path) != item['sha256']:
+            raise ValueError(f"Checksum mismatch: {path}")
+    if release['dataset'] == 'HLP':
+        item = next(x for x in release['files'] if x['path'].endswith('.zip'))
+        path = safe_path(root, item['path'])
+        os.utime(path, ns=(path.stat().st_atime_ns, item['mtime_ns']))
+        if path.stat().st_mtime_ns != item['mtime_ns']:
+            raise ValueError('Filesystem cannot preserve required nanosecond timestamp')
+        print('HLP archive verified; frozen timestamp restored. Use HLP v2 prepared explicitly.')
+        return
+    restored = 0
+    for shard in release['shards']:
+        records = {}
+        with safe_path(root, shard['members']).open(encoding='utf-8') as stream:
+            for line in stream:
+                row = json.loads(line)
+                if row['path'] in records:
+                    raise ValueError('Duplicate member')
+                records[row['path']] = row
+        seen = set()
+        with tarfile.open(safe_path(root, shard['path']), 'r|') as archive:
+            for member in archive:
+                if not member.isfile() or member.name not in records or member.name in seen:
+                    raise ValueError(f'Unexpected archive member: {member.name}')
+                seen.add(member.name)
+                row = records[member.name]
+                if member.size != row['size']:
+                    raise ValueError(f'Wrong member size: {member.name}')
+                target = safe_path(root, member.name)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                # Existing restored files are checked, never blindly overwritten.
+                if target.exists():
+                    if target.stat().st_size != row['size'] or digest(target) != row['sha256']:
+                        raise ValueError(f'Existing file differs: {target}')
+                else:
+                    temporary = target.with_name(target.name + '.hf-restore-partial')
+                    h = hashlib.sha256()
+                    with archive.extractfile(member) as source, temporary.open('wb') as dest:
+                        for block in iter(lambda: source.read(8 * 1024**2), b''):
+                            dest.write(block)
+                            h.update(block)
+                    if h.hexdigest() != row['sha256']:
+                        raise ValueError(f'Member checksum mismatch: {target}')
+                    temporary.replace(target)
+                os.utime(target, ns=(target.stat().st_atime_ns, row['mtime_ns']))
+                if target.stat().st_mtime_ns != row['mtime_ns']:
+                    raise ValueError(f'Filesystem timestamp precision mismatch: {target}')
+                restored += 1
+        if seen != records.keys():
+            raise ValueError(f'Missing members: {shard["path"]}')
+        print(f'Restored and verified {restored} files', flush=True)
+    print('HLC restored; use prepared="processed_data/v1".')
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--root', type=Path, default=Path(__file__).resolve().parents[1])
+    restore(parser.parse_args().root)