#!/usr/bin/env python3 # -*- coding: utf-8 -*- import h5py import numpy as np import torch from torch.utils.data import Dataset, DataLoader from obspy import UTCDateTime DEFAULT_LOCATION = "--" def parse_time(t): return UTCDateTime(str(t)) def decode_attr(value): if isinstance(value, bytes): return value.decode("utf-8", errors="ignore") if isinstance(value, np.bytes_): return value.decode("utf-8", errors="ignore") return value def normalize_location(location, default=DEFAULT_LOCATION): location = decode_attr(location) if location is None: return default location = str(location).strip() return location if location else default def channel_suffix(channel): return str(channel)[-1].upper() def channel_prefix(channel): # 前两位作为 family，例如 BHE/BHN/BHZ -> BH ch = str(channel).upper() if len(ch) >= 3: return ch[:2] return ch[:-1] def component_rank(channel): order = { "E": 0, "1": 0, "N": 1, "2": 1, "Z": 2, "3": 2, } return order.get(channel_suffix(channel), 99) def is_valid_waveform_family(channels): """ 判断一个 channel family 是否可以构成三分量输入。 支持： 1. E/N/Z 2. 1/2/3 3. only Z，后续复制成三分量 """ suffixes = {channel_suffix(ch) for ch in channels} if {"E", "N", "Z"}.issubset(suffixes): return True if {"1", "2", "3"}.issubset(suffixes): return True if suffixes == {"Z"}: return True return False def get_attr(obj, name, default=None): if name in obj.attrs: return decode_attr(obj.attrs[name]) return default def get_float_attr(obj, name, default=np.nan): try: return float(get_attr(obj, name, default)) except Exception: return float(default) def get_bool_attr(obj, name, default=False): value = get_attr(obj, name, default) if isinstance(value, (bool, np.bool_)): return bool(value) if isinstance(value, (int, np.integer)): return bool(value) if isinstance(value, str): return value.lower() in ["true", "1", "yes"] return bool(value) def fill_segments_to_array(segments, fill_value=0.0, dtype=np.float32): if len(segments) == 0: return None, None, None, None segments = sorted(segments, key=lambda x: x["starttime"]) sampling_rate = segments[0]["sampling_rate"] global_start = min(s["starttime"] for s in segments) global_end = max(s["endtime"] for s in segments) npts = int(round((global_end - global_start) * sampling_rate)) + 1 data = np.full(npts, fill_value, dtype=dtype) filled = np.zeros(npts, dtype=bool) for seg in segments: seg_data = seg["data"].astype(dtype, copy=False) i0 = int(round((seg["starttime"] - global_start) * sampling_rate)) i1 = i0 + len(seg_data) if i0 < 0: seg_data = seg_data[-i0:] i0 = 0 if i1 > npts: seg_data = seg_data[: npts - i0] i1 = npts if i0 >= i1: continue target = slice(i0, i1) mask = ~filled[target] data[target][mask] = seg_data[: i1 - i0][mask] filled[target][mask] = True return data, global_start, global_end, sampling_rate def get_position_from_segments(segments): for seg in segments: if seg.get("location_available", False): return { "longitude": seg.get("longitude", np.nan), "latitude": seg.get("latitude", np.nan), "elevation": seg.get("elevation", np.nan), "location_available": True, "location_source": seg.get("location_source", ""), "position_match_mode": seg.get("position_match_mode", ""), "position_is_fallback": seg.get("position_is_fallback", False), "station_position_starttime": seg.get("station_position_starttime", ""), "station_position_endtime": seg.get("station_position_endtime", ""), } return { "longitude": np.nan, "latitude": np.nan, "elevation": np.nan, "location_available": False, "location_source": "default_nan_no_station_record", "position_match_mode": "default_nan_no_station_record", "position_is_fallback": False, "station_position_starttime": "", "station_position_endtime": "", } class HDF5WaveformDataset(Dataset): """ mode: single: 每个 channel 一个样本，返回 [T] three : 每个 channel family 一个样本，返回 [T, 3] multi : 每个 channel family 一个样本，返回 [T, C] """ def __init__( self, h5_file, mode="three", fill_value=0.0, dtype=np.float32, default_location=DEFAULT_LOCATION, ): assert mode in ["single", "three", "multi"] self.h5_file = h5_file self.mode = mode self.fill_value = fill_value self.dtype = dtype self.default_location = default_location self.index = [] self._build_index() def _build_index(self): with h5py.File(self.h5_file, "r") as h5: for year_id in sorted(h5.keys()): year_grp = h5[year_id] for day_id in sorted(year_grp.keys()): day_grp = year_grp[day_id] if "stations" not in day_grp: continue stations_grp = day_grp["stations"] for station_id in sorted(stations_grp.keys()): station_grp = stations_grp[station_id] if "waveform" not in station_grp: continue waveform_grp = station_grp["waveform"] channels = sorted(list(waveform_grp.keys())) if self.mode == "single": for cha in channels: self.index.append( { "year_id": year_id, "day_id": day_id, "station_id": station_id, "channel": cha, } ) else: families = {} for cha in channels: prefix = channel_prefix(cha) families.setdefault(prefix, []).append(cha) for prefix, family_channels in families.items(): family_channels = sorted( family_channels, key=component_rank, ) if self.mode == "three": if not is_valid_waveform_family(family_channels): continue self.index.append( { "year_id": year_id, "day_id": day_id, "station_id": station_id, "channel_family": prefix, "channels": family_channels, } ) def __len__(self): return len(self.index) def _get_station_group(self, h5, year_id, day_id, station_id): return h5[year_id][day_id]["stations"][station_id] def _read_position_history(self, station_grp): if "position_history" not in station_grp: return [] pos_grp = station_grp["position_history"] out = [] for key in sorted(pos_grp.keys(), key=lambda x: int(x) if str(x).isdigit() else str(x)): item = pos_grp[key] out.append( { "network": get_attr(item, "network", ""), "station": get_attr(item, "station", ""), "location": normalize_location( get_attr(item, "location", self.default_location), self.default_location, ), "longitude": get_float_attr(item, "longitude", np.nan), "latitude": get_float_attr(item, "latitude", np.nan), "elevation": get_float_attr(item, "elevation", np.nan), "starttime": get_attr(item, "starttime", ""), "endtime": get_attr(item, "endtime", ""), } ) return out def _read_station_attrs(self, station_grp): location = normalize_location( get_attr(station_grp, "location", self.default_location), self.default_location, ) return { "station_id": get_attr(station_grp, "station_id", ""), "network": get_attr(station_grp, "network", ""), "station": get_attr(station_grp, "station", ""), "location": location, "location_is_default": get_bool_attr( station_grp, "location_is_default", location == self.default_location, ), "longitude": get_float_attr(station_grp, "longitude", np.nan), "latitude": get_float_attr(station_grp, "latitude", np.nan), "elevation": get_float_attr(station_grp, "elevation", np.nan), "location_available": get_bool_attr(station_grp, "location_available", False), "location_source": get_attr(station_grp, "location_source", ""), "position_match_mode": get_attr(station_grp, "position_match_mode", ""), "position_is_fallback": get_bool_attr(station_grp, "position_is_fallback", False), "station_position_starttime": get_attr(station_grp, "station_position_starttime", ""), "station_position_endtime": get_attr(station_grp, "station_position_endtime", ""), "instrument_time_range_start": get_attr(station_grp, "instrument_time_range_start", ""), "instrument_time_range_end": get_attr(station_grp, "instrument_time_range_end", ""), "position_history": self._read_position_history(station_grp), } def _read_channel_attrs(self, channel_grp): return { "channel": get_attr(channel_grp, "channel", ""), "segment_count": int(get_attr(channel_grp, "segment_count", 0)), "starttime": get_attr(channel_grp, "starttime", ""), "endtime": get_attr(channel_grp, "endtime", ""), "longitude": get_float_attr(channel_grp, "longitude", np.nan), "latitude": get_float_attr(channel_grp, "latitude", np.nan), "elevation": get_float_attr(channel_grp, "elevation", np.nan), "location_available": get_bool_attr(channel_grp, "location_available", False), "location_source": get_attr(channel_grp, "location_source", ""), "position_match_mode": get_attr(channel_grp, "position_match_mode", ""), "position_is_fallback": get_bool_attr(channel_grp, "position_is_fallback", False), "station_position_starttime": get_attr(channel_grp, "station_position_starttime", ""), "station_position_endtime": get_attr(channel_grp, "station_position_endtime", ""), } def _read_channel_segments(self, h5, year_id, day_id, station_id, channel): station_grp = self._get_station_group(h5, year_id, day_id, station_id) channel_grp = station_grp["waveform"][channel] segments = [] for ds_key in sorted(channel_grp.keys(), key=lambda x: int(x)): ds = channel_grp[ds_key] segments.append( { "data": ds[()], "segment_index": int(get_attr(ds, "segment_index", ds_key)), "starttime": parse_time(get_attr(ds, "starttime", "")), "endtime": parse_time(get_attr(ds, "endtime", "")), "sampling_rate": float(get_attr(ds, "sampling_rate", np.nan)), "delta": float(get_attr(ds, "delta", np.nan)), "npts": int(get_attr(ds, "npts", ds.shape[0])), "network": get_attr(ds, "network", ""), "station": get_attr(ds, "station", ""), "location": normalize_location( get_attr(ds, "location", self.default_location), self.default_location, ), "channel": get_attr(ds, "channel", channel), "mseed_source_file": get_attr(ds, "mseed_source_file", ""), "dtype": get_attr(ds, "dtype", str(ds.dtype)), "longitude": get_float_attr(ds, "longitude", np.nan), "latitude": get_float_attr(ds, "latitude", np.nan), "elevation": get_float_attr(ds, "elevation", np.nan), "location_available": get_bool_attr(ds, "location_available", False), "location_source": get_attr(ds, "location_source", ""), "station_position_starttime": get_attr(ds, "station_position_starttime", ""), "station_position_endtime": get_attr(ds, "station_position_endtime", ""), "position_match_mode": get_attr(ds, "position_match_mode", ""), "position_is_fallback": get_bool_attr(ds, "position_is_fallback", False), } ) channel_info = self._read_channel_attrs(channel_grp) return segments, channel_info def __getitem__(self, idx): item = self.index[idx] with h5py.File(self.h5_file, "r") as h5: year_id = item["year_id"] day_id = item["day_id"] station_id = item["station_id"] station_grp = self._get_station_group(h5, year_id, day_id, station_id) station_info = self._read_station_attrs(station_grp) if self.mode == "single": return self._getitem_single(h5, item, station_info) if self.mode == "three": return self._getitem_three(h5, item, station_info) if self.mode == "multi": return self._getitem_multi(h5, item, station_info) raise ValueError(f"Unsupported mode: {self.mode}") def _getitem_single(self, h5, item, station_info): year_id = item["year_id"] day_id = item["day_id"] station_id = item["station_id"] channel = item["channel"] segments, channel_info = self._read_channel_segments( h5, year_id, day_id, station_id, channel ) waveform, starttime, endtime, sr = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, ) if waveform is None: waveform = np.zeros(0, dtype=self.dtype) position_info = get_position_from_segments(segments) station_info = dict(station_info) station_info.update(position_info) return { "mode": "single", "year_id": year_id, "day_id": day_id, "station_id": station_id, "station_info": station_info, "channel_info": channel_info, "channel": channel, "channels": [channel], "waveform": torch.from_numpy(waveform), "segments": [ {k: v for k, v in seg.items() if k != "data"} for seg in segments ], "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "sampling_rate": sr, "npts": waveform.shape[0], } def _getitem_three(self, h5, item, station_info): year_id = item["year_id"] day_id = item["day_id"] station_id = item["station_id"] channel_family = item["channel_family"] candidate_channels = item["channels"] selected = {} for cha in candidate_channels: suf = channel_suffix(cha) if suf in ["E", "1"] and 0 not in selected: selected[0] = cha elif suf in ["N", "2"] and 1 not in selected: selected[1] = cha elif suf in ["Z", "3"] and 2 not in selected: selected[2] = cha z_only_replicated = False # 只有 Z 的情况：复制为三分量 if 2 in selected and 0 not in selected and 1 not in selected: selected[0] = selected[2] selected[1] = selected[2] z_only_replicated = True arrays = {} starts = [] ends = [] srs = [] all_segments = [] channel_infos = {} # 避免 Z-only 情况重复读取同一个 channel 三次 unique_channels = sorted(set(selected.values())) channel_arrays = {} for cha in unique_channels: segments, channel_info = self._read_channel_segments( h5, year_id, day_id, station_id, cha ) all_segments.extend(segments) channel_infos[cha] = channel_info arr, st, et, sr = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, ) if arr is None: continue channel_arrays[cha] = arr starts.append(st) ends.append(et) srs.append(sr) for comp_idx, cha in selected.items(): if cha in channel_arrays: arrays[comp_idx] = channel_arrays[cha] if len(arrays) == 0: waveform = np.zeros((0, 3), dtype=self.dtype) starttime = None endtime = None sr = np.nan else: sr = srs[0] starttime = min(starts) endtime = max(ends) max_len = max(len(a) for a in arrays.values()) waveform = np.full((max_len, 3), self.fill_value, dtype=self.dtype) for comp_idx, arr in arrays.items(): waveform[: len(arr), comp_idx] = arr position_info = get_position_from_segments(all_segments) station_info = dict(station_info) station_info.update(position_info) channels_out = [ selected.get(0, ""), selected.get(1, ""), selected.get(2, ""), ] return { "mode": "three", "year_id": year_id, "day_id": day_id, "station_id": station_id, "station_info": station_info, "channel_family": channel_family, "channel_info": channel_infos, "channels": channels_out, "component_order": "E/N/Z or 1/2/3; Z-only is replicated", "z_only_replicated": z_only_replicated, "waveform": torch.from_numpy(waveform), "segments": [ {k: v for k, v in seg.items() if k != "data"} for seg in all_segments ], "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "sampling_rate": sr, "npts": waveform.shape[0], } def _getitem_multi(self, h5, item, station_info): year_id = item["year_id"] day_id = item["day_id"] station_id = item["station_id"] channel_family = item["channel_family"] channels = item["channels"] arrays = [] used_channels = [] starts = [] ends = [] srs = [] all_segments = [] channel_infos = {} for cha in channels: segments, channel_info = self._read_channel_segments( h5, year_id, day_id, station_id, cha ) all_segments.extend(segments) channel_infos[cha] = channel_info arr, st, et, sr = fill_segments_to_array( segments, fill_value=self.fill_value, dtype=self.dtype, ) if arr is None: continue arrays.append(arr) used_channels.append(cha) starts.append(st) ends.append(et) srs.append(sr) if len(arrays) == 0: waveform = np.zeros((0, 0), dtype=self.dtype) starttime = None endtime = None sr = np.nan else: max_len = max(len(a) for a in arrays) waveform = np.full( (max_len, len(arrays)), self.fill_value, dtype=self.dtype, ) for i, arr in enumerate(arrays): waveform[: len(arr), i] = arr starttime = min(starts) endtime = max(ends) sr = srs[0] position_info = get_position_from_segments(all_segments) station_info = dict(station_info) station_info.update(position_info) return { "mode": "multi", "year_id": year_id, "day_id": day_id, "station_id": station_id, "station_info": station_info, "channel_family": channel_family, "channel_info": channel_infos, "channels": used_channels, "waveform": torch.from_numpy(waveform), "segments": [ {k: v for k, v in seg.items() if k != "data"} for seg in all_segments ], "starttime": str(starttime) if starttime is not None else "", "endtime": str(endtime) if endtime is not None else "", "sampling_rate": sr, "npts": waveform.shape[0], } def waveform_collate_fn(batch): return batch def padded_collate_fn(batch, fill_value=0.0): lengths = [] arrays = [] max_t = 0 max_c = 1 for item in batch: x = item["waveform"] if x.ndim == 1: x = x[:, None] t, c = x.shape max_t = max(max_t, t) max_c = max(max_c, c) lengths.append(t) arrays.append(x) out = torch.full( (len(batch), max_t, max_c), fill_value=float(fill_value), dtype=arrays[0].dtype, ) for i, x in enumerate(arrays): t, c = x.shape out[i, :t, :c] = x meta = [] for item in batch: d = dict(item) d.pop("waveform") meta.append(d) return { "waveform": out, "lengths": torch.tensor(lengths, dtype=torch.long), "meta": meta, } if __name__ == "__main__": h5_file = "data/continuous_waveform_usa.h5" dataset = HDF5WaveformDataset( h5_file=h5_file, mode="three", fill_value=0.0, dtype=np.float32, default_location="--", ) loader = DataLoader( dataset, batch_size=2, shuffle=False, num_workers=0, collate_fn=waveform_collate_fn, ) print("Number of samples:", len(dataset)) for batch in loader: for item in batch: print("=" * 80) print("station_id:", item["station_id"]) print("station_info:", item["station_info"]) print("mode:", item["mode"]) print("channel_family:", item["channel_family"]) print("channels:", item["channels"]) print("z_only_replicated:", item["z_only_replicated"]) print("starttime:", item["starttime"]) print("endtime:", item["endtime"]) print("sampling_rate:", item["sampling_rate"]) print("waveform shape:", tuple(item["waveform"].shape)) print("first segment meta:", item["segments"][0] if item["segments"] else None) break