| |
| |
|
|
| 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): |
| |
| 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 |
|
|
| |
| 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 = {} |
|
|
| |
| 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 |
