| |
| """Independent structural, physical, temporal, missingness, and spatial QA for the release.""" |
| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
| import numpy as np |
| import pandas as pd |
|
|
| DATA = Path('air_quality_100m.npy') |
| META = Path('stations.csv') |
| GRAPH = Path('spatial_graph_knn10.csv') |
| OUT = Path('validation_report.json') |
| N_STATIONS = 1000 |
| N_HOURS = 100_000 |
| N_ROWS = N_STATIONS * N_HOURS |
| TZ = 'Asia/Kolkata' |
| FIELDS = ['temperature_c','relative_humidity_pct','wind_speed_ms','rainfall_mm','pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3'] |
| BITS = {f:i for i,f in enumerate(FIELDS)} |
| ALL_MASK = (1 << len(FIELDS)) - 1 |
|
|
|
|
| def corr_lag(a, lag): |
| a = np.asarray(a, dtype=np.float64) |
| m = np.isfinite(a[:-lag]) & np.isfinite(a[lag:]) |
| if m.sum() < 10: |
| return float('nan') |
| return float(np.corrcoef(a[:-lag][m], a[lag:][m])[0,1]) |
|
|
|
|
| def missing_run_lengths(mask_bool): |
| x = np.asarray(mask_bool, dtype=np.int8) |
| if not x.any(): return np.empty(0, dtype=np.int32) |
| d = np.diff(np.r_[0, x, 0]) |
| starts = np.flatnonzero(d == 1); ends = np.flatnonzero(d == -1) |
| return (ends - starts).astype(np.int32) |
|
|
|
|
| def haversine_pairs(meta, ids): |
| lat = np.radians(meta.loc[ids,'latitude'].to_numpy(dtype=np.float64)) |
| lon = np.radians(meta.loc[ids,'longitude'].to_numpy(dtype=np.float64)) |
| out=[] |
| for i in range(len(ids)): |
| for j in range(i+1,len(ids)): |
| dlat=lat[j]-lat[i]; dlon=lon[j]-lon[i] |
| a=np.sin(dlat/2)**2 + np.cos(lat[i])*np.cos(lat[j])*np.sin(dlon/2)**2 |
| out.append(6371.0088*2*np.arcsin(np.sqrt(np.clip(a,0,1)))) |
| return np.asarray(out,dtype=np.float64) |
|
|
|
|
| def main(): |
| arr = np.load(DATA, mmap_mode='r') |
| shape_ok = arr.shape == (N_ROWS,) |
| mins={f:float('inf') for f in FIELDS}; maxs={f:float('-inf') for f in FIELDS}; sums={f:0. for f in FIELDS}; counts={f:0 for f in FIELDS} |
| miss_counts={f:0 for f in FIELDS} |
| violations={k:0 for k in ['pm_order','rh','temp','wind','rain','pollutant_negative','mask_nan_mismatch','bad_obs_mask_bits','bad_split','bad_event']} |
| split_counts=np.zeros(3,dtype=np.int64); event_counts=np.zeros(5,dtype=np.int64) |
| cap_counts={'pm25_950':0,'pm10_1200':0,'no2_250':0,'co_12':0,'so2_120':0,'o3_300':0} |
| step=1_000_000 |
| for a in range(0,N_ROWS,step): |
| x=arr[a:a+step] |
| split_counts += np.bincount(x['split_code'],minlength=3)[:3] |
| event_counts += np.bincount(x['event_code'],minlength=5)[:5] |
| violations['bad_split'] += int(np.sum(x['split_code']>2)) |
| violations['bad_event'] += int(np.sum(x['event_code']>4)) |
| violations['bad_obs_mask_bits'] += int(np.sum((x['obs_mask'].astype(np.uint32) & np.uint32(~ALL_MASK & 0xFFFF)) != 0)) |
| obs_by={} |
| for f,bit in BITS.items(): |
| obs=(x['obs_mask'] & np.uint16(1<<bit)) != 0 |
| obs_by[f]=obs |
| finite=np.isfinite(x[f]) |
| miss_counts[f] += int((~obs).sum()) |
| violations['mask_nan_mismatch'] += int(np.sum(obs != finite)) |
| v=x[f][obs] |
| if len(v): |
| mins[f]=min(mins[f],float(np.min(v))); maxs[f]=max(maxs[f],float(np.max(v))) |
| sums[f]+=float(np.sum(v,dtype=np.float64)); counts[f]+=len(v) |
| both=obs_by['pm25_ugm3'] & obs_by['pm10_ugm3'] |
| violations['pm_order'] += int(np.sum(both & (x['pm10_ugm3'] < x['pm25_ugm3']))) |
| rhobs=obs_by['relative_humidity_pct']; violations['rh'] += int(np.sum(rhobs & ((x['relative_humidity_pct']<0)|(x['relative_humidity_pct']>100)))) |
| tobs=obs_by['temperature_c']; violations['temp'] += int(np.sum(tobs & ((x['temperature_c']<-5)|(x['temperature_c']>50)))) |
| wobs=obs_by['wind_speed_ms']; violations['wind'] += int(np.sum(wobs & (x['wind_speed_ms']<0))) |
| robs=obs_by['rainfall_mm']; violations['rain'] += int(np.sum(robs & (x['rainfall_mm']<0))) |
| for f in ['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3']: |
| violations['pollutant_negative'] += int(np.sum(obs_by[f] & (x[f]<0))) |
| cap_counts['pm25_950'] += int(np.sum(obs_by['pm25_ugm3'] & np.isclose(x['pm25_ugm3'],950))) |
| cap_counts['pm10_1200'] += int(np.sum(obs_by['pm10_ugm3'] & np.isclose(x['pm10_ugm3'],1200))) |
| cap_counts['no2_250'] += int(np.sum(obs_by['no2_ugm3'] & np.isclose(x['no2_ugm3'],250))) |
| cap_counts['co_12'] += int(np.sum(obs_by['co_mgm3'] & np.isclose(x['co_mgm3'],12))) |
| cap_counts['so2_120'] += int(np.sum(obs_by['so2_ugm3'] & np.isclose(x['so2_ugm3'],120))) |
| cap_counts['o3_300'] += int(np.sum(obs_by['o3_ugm3'] & np.isclose(x['o3_ugm3'],300))) |
|
|
| |
| base_ts=arr[:N_HOURS]['timestamp_utc_s'].copy() |
| expected_split=np.where(np.arange(N_HOURS)<80_000,0,np.where(np.arange(N_HOURS)<90_000,1,2)).astype(np.uint8) |
| key_errors=0; split_structure_errors=0 |
| for sid in range(N_STATIONS): |
| x=arr[sid*N_HOURS:(sid+1)*N_HOURS] |
| if not np.all(x['station_id']==sid): key_errors+=1 |
| if not np.array_equal(x['timestamp_utc_s'],base_ts): key_errors+=1 |
| if not np.array_equal(x['split_code'],expected_split): split_structure_errors+=1 |
| cadence_ok=bool(np.all(np.diff(base_ts)==3600)) |
| order_consistency=1.0 if np.all(np.diff(base_ts)>=0) else float(np.mean(np.diff(base_ts)>=0)) |
| uniqueness=1.0 if len(np.unique(base_ts))==N_HOURS else len(np.unique(base_ts))/N_HOURS |
| regularity=1.0 if cadence_ok else float(np.mean(np.diff(base_ts)==3600)) |
| grid_completeness=len(base_ts)/N_HOURS |
| start_local=pd.to_datetime(int(base_ts[0]),unit='s',utc=True).tz_convert(TZ) |
| end_local=pd.to_datetime(int(base_ts[-1]),unit='s',utc=True).tz_convert(TZ) |
|
|
| meta=pd.read_csv(META) |
| graph=pd.read_csv(GRAPH) |
| graph_ok=(len(graph)==N_STATIONS*10 and (graph.source_station_id!=graph.target_station_id).all() and (graph.distance_km>0).all() and graph.groupby('source_station_id').size().eq(10).all()) |
| metadata_ok=(len(meta)==N_STATIONS and meta.station_id.nunique()==N_STATIONS and bool(meta.is_synthetic.all())) |
|
|
| |
| x0=arr[:N_HOURS] |
| idx_local=pd.to_datetime(base_ts,unit='s',utc=True).tz_convert(TZ) |
| months=idx_local.month.to_numpy(); hours=idx_local.hour.to_numpy() |
| acf={} |
| for f in ['temperature_c','pm25_ugm3','no2_ugm3','o3_ugm3']: |
| acf[f]={str(lag):corr_lag(x0[f],lag) for lag in [1,24,168]} |
| corr_fields=['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3','wind_speed_ms','rainfall_mm'] |
| corr_df=pd.DataFrame({f:x0[f] for f in corr_fields}).corr() |
| cross_corr={f:{g:float(corr_df.loc[f,g]) for g in corr_fields} for f in corr_fields} |
|
|
| |
| first_diff={} |
| for f in ['temperature_c','pm25_ugm3','no2_ugm3','o3_ugm3']: |
| a=x0[f].astype(np.float64); m=np.isfinite(a[:-1])&np.isfinite(a[1:]); d=a[1:][m]-a[:-1][m] |
| first_diff[f]={'mean':float(d.mean()),'std':float(d.std()),'median_abs':float(np.median(np.abs(d))),'p99_abs':float(np.quantile(np.abs(d),.99))} |
|
|
| |
| df0=pd.DataFrame({'month':months,'temp':x0['temperature_c'],'rh':x0['relative_humidity_pct'],'rain':x0['rainfall_mm'],'pm25':x0['pm25_ugm3'],'pm10':x0['pm10_ugm3'],'no2':x0['no2_ugm3'],'o3':x0['o3_ugm3']}) |
| monthly=df0.groupby('month').agg(['mean','min','max']).round(3) |
| jan=months==1; jan_min=float('inf'); jan_max=float('-inf') |
| for sid in np.linspace(0,999,20,dtype=int): |
| xx=arr[sid*N_HOURS:(sid+1)*N_HOURS]['temperature_c'] |
| jan_min=min(jan_min,float(np.nanmin(xx[jan]))); jan_max=max(jan_max,float(np.nanmax(xx[jan]))) |
|
|
| |
| ev=x0['event_code']; event_effects={} |
| for code,name in [(1,'diwali'),(2,'lockdown'),(3,'cyclone')]: |
| em=ev==code |
| if em.any(): |
| months_ev=np.unique(months[em]); ctrl=np.isin(months,months_ev)&(ev==0) |
| res={} |
| for f in ['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3']: |
| bit=BITS[f]; om=(x0['obs_mask']&(1<<bit))!=0 |
| a=x0[f][em&om]; b=x0[f][ctrl&om] |
| res[f]=float(np.nanmedian(a)/np.nanmedian(b)) |
| event_effects[name]=res |
|
|
| |
| run_summary={f:[] for f in FIELDS} |
| for sid in np.linspace(0,999,20,dtype=int): |
| m=arr[sid*N_HOURS:(sid+1)*N_HOURS]['obs_mask'] |
| for f,bit in BITS.items(): |
| runs=missing_run_lengths((m&(1<<bit))==0) |
| if len(runs): run_summary[f].extend(runs.tolist()) |
| run_stats={} |
| for f,runs in run_summary.items(): |
| r=np.asarray(runs,dtype=np.float64) |
| run_stats[f]={'n_runs':int(len(r)),'mean_hours':float(r.mean()),'median_hours':float(np.median(r)),'p95_hours':float(np.quantile(r,.95)),'max_hours':int(r.max())} |
|
|
| |
| sample_ids=np.linspace(0,999,120,dtype=int) |
| tidx=np.linspace(0,N_HOURS-1,6000,dtype=int) |
| X=np.empty((len(tidx),len(sample_ids)),dtype=np.float32) |
| for j,sid in enumerate(sample_ids): |
| X[:,j]=arr[sid*N_HOURS:(sid+1)*N_HOURS]['pm25_ugm3'][tidx] |
| raw_corr=pd.DataFrame(X).corr(min_periods=3000).to_numpy() |
| residual=X-np.nanmean(X,axis=1,keepdims=True) |
| residual_corr=pd.DataFrame(residual).corr(min_periods=3000).to_numpy() |
| dists=haversine_pairs(meta,sample_ids) |
| raw_pairs=[]; res_pairs=[] |
| for i in range(len(sample_ids)): |
| for j in range(i+1,len(sample_ids)): |
| raw_pairs.append(raw_corr[i,j]); res_pairs.append(residual_corr[i,j]) |
| raw_pairs=np.asarray(raw_pairs,dtype=float); res_pairs=np.asarray(res_pairs,dtype=float) |
| bins=[0,5,10,15,20,30,40,60] |
| spatial_bins=[] |
| for lo,hi in zip(bins[:-1],bins[1:]): |
| m=(dists>=lo)&(dists<hi)&np.isfinite(raw_pairs)&np.isfinite(res_pairs) |
| spatial_bins.append({'lo_km':lo,'hi_km':hi,'n_pairs':int(m.sum()),'raw_corr_mean':float(np.mean(raw_pairs[m])) if m.any() else None,'residual_corr_mean':float(np.mean(res_pairs[m])) if m.any() else None}) |
| spatial_raw_r=float(np.corrcoef(dists,raw_pairs)[0,1]); spatial_resid_r=float(np.corrcoef(dists,res_pairs)[0,1]) |
| near=np.isfinite(raw_pairs)&(dists<5); far=np.isfinite(raw_pairs)&(dists>=30) |
| near_raw=float(np.mean(raw_pairs[near])); far_raw=float(np.mean(raw_pairs[far])) |
| near_res=float(np.mean(res_pairs[near])); far_res=float(np.mean(res_pairs[far])) |
| spatial_design_ok=(spatial_raw_r < -0.20 and near_raw > far_raw + 0.02 and near_res > far_res + 0.10) |
|
|
| |
| relation_checks={ |
| 'pm10_ge_pm25_all_joint_observations': violations['pm_order']==0, |
| 'pm25_wind_negative_corr_station0': cross_corr['pm25_ugm3']['wind_speed_ms'] < -0.05, |
| 'pm25_rain_negative_corr_station0': cross_corr['pm25_ugm3']['rainfall_mm'] < -0.02, |
| 'no2_o3_negative_corr_station0': cross_corr['no2_ugm3']['o3_ugm3'] < 0, |
| 'pm25_pm10_high_but_not_identical_corr_station0': 0.80 < cross_corr['pm25_ugm3']['pm10_ugm3'] < 0.9999, |
| 'spatial_distance_decay': spatial_design_ok, |
| } |
|
|
| hard_ok=(shape_ok and key_errors==0 and split_structure_errors==0 and cadence_ok and metadata_ok and graph_ok and all(v==0 for v in violations.values()) and all(relation_checks.values())) |
| report={ |
| 'status':'PASS' if hard_ok else 'FAIL', |
| 'scope':'internal synthetic-design validation; not an empirical equivalence claim against real Kolkata monitoring data', |
| 'rows':N_ROWS,'stations':N_STATIONS,'hours_per_station':N_HOURS,'file_size_bytes':DATA.stat().st_size, |
| 'start_local':str(start_local),'end_local':str(end_local), |
| 'timestamp_fidelity':{'order_consistency':order_consistency,'uniqueness':uniqueness,'regularity_consistency':regularity,'grid_completeness':grid_completeness,'key_errors':key_errors,'split_structure_errors':split_structure_errors}, |
| 'split_rows':{'train':int(split_counts[0]),'validation':int(split_counts[1]),'test':int(split_counts[2])}, |
| 'event_rows':{'normal':int(event_counts[0]),'diwali':int(event_counts[1]),'lockdown':int(event_counts[2]),'cyclone':int(event_counts[3]),'heatwave':int(event_counts[4])}, |
| 'missingness':{ |
| 'per_field_rows':miss_counts, |
| 'per_field_rates':{f:miss_counts[f]/N_ROWS for f in FIELDS}, |
| 'run_length_sample20':run_stats, |
| }, |
| 'violations':violations, |
| 'min':mins,'max':maxs,'mean':{f:sums[f]/counts[f] for f in FIELDS},'cap_counts':cap_counts, |
| 'jan_temperature_sample20_minmax_c':[jan_min,jan_max], |
| 'autocorrelation_station0':acf,'first_difference_station0':first_diff,'cross_correlation_station0':cross_corr, |
| 'spatial_pm25':{'distance_vs_raw_corr_r':spatial_raw_r,'distance_vs_residual_corr_r':spatial_resid_r,'near_lt5km_raw':near_raw,'far_ge30km_raw':far_raw,'near_lt5km_residual':near_res,'far_ge30km_residual':far_res,'bins':spatial_bins,'design_check_pass':spatial_design_ok}, |
| 'relation_checks':relation_checks, |
| 'station0_event_effect_median_ratios':event_effects, |
| 'station0_monthly':{str(m):{f'{col}_{stat}':float(monthly.loc[m,(col,stat)]) for col in ['temp','rh','rain','pm25','pm10','no2','o3'] for stat in ['mean','min','max']} for m in monthly.index}, |
| 'metadata':{'rows':len(meta),'ok':metadata_ok,'site_type_counts':meta.site_type.value_counts().to_dict()}, |
| 'graph':{'rows':len(graph),'k':10,'ok':bool(graph_ok),'distance_km_min':float(graph.distance_km.min()),'distance_km_max':float(graph.distance_km.max()),'distance_km_mean':float(graph.distance_km.mean())}, |
| } |
| OUT.write_text(json.dumps(report,indent=2)) |
| print(json.dumps(report,indent=2)) |
|
|
| if __name__=='__main__': main() |
|
|
