seismic network update

README.md

@@ -1,3 +1,133 @@
 ---
 license: mit
 ---
+
+# Quakeflow_NC
+
+## Introduction
+This dataset is part of the data from NCEDC (Northern California Earthquake Data Center) and is organised as several HDF5 files. The dataset structure is shown below: (File [ncedc_event_dataset_000.h5.txt](./ncedc_event_dataset_000.h5.txt) shows the structure of the firsr shard of the dataset, and you can find more information about the format at [AI4EPS](https://ai4eps.github.io/homepage/ml4earth/seismic_event_format1/))
+
+```
+Group: / len:10000
+  |- Group: /nc100012 len:5
+  |  |-* begin_time = 1987-05-08T00:15:48.890
+  |  |-* depth_km = 7.04
+  |  |-* end_time = 1987-05-08T00:17:48.890
+  |  |-* event_id = nc100012
+  |  |-* event_time = 1987-05-08T00:16:14.700
+  |  |-* event_time_index = 2581
+  |  |-* latitude = 37.5423
+  |  |-* longitude = -118.4412
+  |  |-* magnitude = 1.1
+  |  |-* magnitude_type = D
+  |  |-* num_stations = 5
+  |  |- Dataset: /nc100012/NC.MRS..EH (shape:(3, 12000))
+  |  |  |- (dtype=float32)
+  |  |  |  |-* azimuth = 265.0
+  |  |  |  |-* component = ['Z']
+  |  |  |  |-* distance_km = 39.1
+  |  |  |  |-* dt_s = 0.01
+  |  |  |  |-* elevation_m = 3680.0
+  |  |  |  |-* emergence_angle = 93.0
+  |  |  |  |-* event_id = ['nc100012' 'nc100012']
+  |  |  |  |-* latitude = 37.5107
+  |  |  |  |-* location = 
+  |  |  |  |-* longitude = -118.8822
+  |  |  |  |-* network = NC
+  |  |  |  |-* phase_index = [3274 3802]
+  |  |  |  |-* phase_polarity = ['U' 'N']
+  |  |  |  |-* phase_remark = ['IP' 'S']
+  |  |  |  |-* phase_score = [1 1]
+  |  |  |  |-* phase_time = ['1987-05-08T00:16:21.630' '1987-05-08T00:16:26.920']
+  |  |  |  |-* phase_type = ['P' 'S']
+  |  |  |  |-* snr = [0.         0.         1.98844361]
+  |  |  |  |-* station = MRS
+  |  |  |  |-* unit = 1e-6m/s
+  |  |- Dataset: /nc100012/NN.BEN.N1.EH (shape:(3, 12000))
+  |  |  |- (dtype=float32)
+  |  |  |  |-* azimuth = 329.0
+  |  |  |  |-* component = ['Z']
+  |  |  |  |-* distance_km = 22.5
+  |  |  |  |-* dt_s = 0.01
+  |  |  |  |-* elevation_m = 2476.0
+  |  |  |  |-* emergence_angle = 102.0
+  |  |  |  |-* event_id = ['nc100012' 'nc100012']
+  |  |  |  |-* latitude = 37.7154
+  |  |  |  |-* location = N1
+  |  |  |  |-* longitude = -118.5741
+  |  |  |  |-* network = NN
+  |  |  |  |-* phase_index = [3010 3330]
+  |  |  |  |-* phase_polarity = ['U' 'N']
+  |  |  |  |-* phase_remark = ['IP' 'S']
+  |  |  |  |-* phase_score = [0 0]
+  |  |  |  |-* phase_time = ['1987-05-08T00:16:18.990' '1987-05-08T00:16:22.190']
+  |  |  |  |-* phase_type = ['P' 'S']
+  |  |  |  |-* snr = [0.         0.         7.31356192]
+  |  |  |  |-* station = BEN
+  |  |  |  |-* unit = 1e-6m/s
+  ......
+  ```
+
+## How to use
+
+### Requirements
+- datasets
+- h5py
+- torch (for PyTorch)
+
+### Usage
+```python
+import h5py
+import numpy as np
+import torch
+from torch.utils.data import Dataset, IterableDataset, DataLoader
+from datasets import load_dataset
+
+# load dataset
+# ATTENTION: Streaming(Iterable Dataset) is difficult to support because of the feature of HDF5
+# So we recommend to directly load the dataset and convert it into iterable later
+# The dataset is very large, so you need to wait for some time at the first time
+quakeflow_nc = datasets.load_dataset("AI4EPS/quakeflow_nc", split="train")
+quakeflow_nc
+```
+If you want to use the first several shards of the dataset, you can download the script `quakeflow_nc.py` and change the code below:
+```python
+# change the 37 to the number of shards you want
+_URLS = {
+    "NCEDC": [f"{_REPO}/ncedc_event_dataset_{i:03d}.h5" for i in range(37)]
+}
+```
+Then you can use the dataset like this:
+```python
+quakeflow_nc = datasets.load_dataset("./quakeflow_nc.py", split="train")
+quakeflow_nc
+```
+Then you can change the dataset into PyTorch format iterable dataset, and view the first sample:
+```python
+quakeflow_nc = quakeflow_nc.to_iterable_dataset()
+quakeflow_nc = quakeflow_nc.with_format("torch")
+# because add examples formatting to get tensors when using the "torch" format
+# has not been implemented yet, we need to manually add the formatting
+quakeflow_nc = quakeflow_nc.map(lambda x: {key: torch.from_numpy(np.array(value, dtype=np.float32)) for key, value in x.items()})
+try:
+    isinstance(quakeflow_nc, torch.utils.data.IterableDataset)
+except:
+    raise Exception("quakeflow_nc is not an IterableDataset")
+
+# print the first sample of the iterable dataset
+for example in quakeflow_nc:
+    print("\nIterable test\n")
+    print(example.keys())
+    for key in example.keys():
+        print(key, example[key].shape, example[key].dtype)
+    break
+
+dataloader = DataLoader(quakeflow_nc, batch_size=4)
+
+for batch in dataloader:
+    print("\nDataloader test\n")
+    print(batch.keys())
+    for key in batch.keys():
+        print(key, batch[key].shape, batch[key].dtype)
+    break
+```

quakeflow_nc.py

@@ -21,7 +21,11 @@ import csv
 import json
 import os
 import h5py
+import numpy as np
+import torch
+import fsspec
 from glob import glob
+from typing import Dict, List, Optional, Tuple, Union
 
 import datasets
 
@@ -52,7 +56,7 @@ _LICENSE = ""
 # TODO: Add link to the official dataset URLs here
 # The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
 # This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
-_REPO = "https://huggingface.co/datasets/AI4EPS/QuakeFlow_NC/resolve/main/data"
+_REPO = "https://huggingface.co/datasets/AI4EPS/quakeflow_nc/resolve/main/data"
 _URLS = {
     "NCEDC": [f"{_REPO}/ncedc_event_dataset_{i:03d}.h5" for i in range(37)]
 }
@@ -85,9 +89,10 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
         # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
         features=datasets.Features(
             {
-                "event_id": datasets.Value("string"),
-                "station_id": datasets.Value("string"),
-                "waveform": datasets.Array2D(shape=(3, 12000), dtype="float32"),
+                "waveform": datasets.Array3D(shape=(3, self.nt, self.num_stations), dtype='float32'),
+                "phase_pick": datasets.Array3D(shape=(3, self.nt, self.num_stations), dtype='float32'),
+                "event_location": [datasets.Value("float32")],
+                "station_location": datasets.Array2D(shape=(self.num_stations, 3), dtype="float32"),
             }
         )
         return datasets.DatasetInfo(
@@ -144,21 +149,73 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             #     },
             # ),
         ]
+        
+    degree2km = 111.32
+    nt = 8192
+    feature_nt = 512
+    feature_scale = int(nt / feature_nt)
+    sampling_rate=100.0
+    num_stations = 10
 
     # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
     def _generate_examples(self, filepath, split):
         # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
         # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
-
+        num_stations = self.num_stations
+        
         for file in filepath:
             with h5py.File(file, "r") as fp:
-                for event_id in sorted(list(fp.keys())):
+                # for event_id in sorted(list(fp.keys())):
+                for event_id in fp.keys():
                     event = fp[event_id]
-                    for station_id in sorted(list(event.keys())):
-                        station = event[station_id]
-                        # print(f"{event_id = } {station_id = }")
-                        yield event_id + "_" + station_id, {
-                            "event_id": event_id,
-                            "station_id": station_id,
-                            "waveform": station[:],
-                        }
+                    station_ids = list(event.keys())
+                    if len(station_ids) < num_stations:
+                        continue
+                    else:
+                        station_ids = np.random.choice(station_ids, num_stations, replace=False)
+                        
+                    waveforms = np.zeros([3, self.nt, len(station_ids)])
+                    phase_pick = np.zeros_like(waveforms)
+                    attrs = event.attrs
+                    event_location = [attrs["longitude"], attrs["latitude"], attrs["depth_km"], attrs["event_time_index"]]
+                    station_location = []
+                    
+                    for i, sta_id in enumerate(station_ids):
+                        # trace_id = event_id + "/" + sta_id
+                        
+                        waveforms[:, :, i] = event[sta_id][:,:self.nt]
+                        attrs = event[sta_id].attrs
+                        p_picks = attrs["phase_index"][attrs["phase_type"] == "P"]
+                        s_picks = attrs["phase_index"][attrs["phase_type"] == "S"]
+                        phase_pick[:, :, i] = generate_label([p_picks, s_picks], nt=self.nt)
+                        
+                        station_location.append([attrs["longitude"], attrs["latitude"], -attrs["elevation_m"]/1e3])
+                        
+                    std = np.std(waveforms, axis=1, keepdims=True)
+                    std[std == 0] = 1.0
+                    waveforms = (waveforms - np.mean(waveforms, axis=1, keepdims=True)) / std
+                    waveforms = waveforms.astype(np.float32)
+                    
+                    yield event_id, {
+                        "waveform": torch.from_numpy(waveforms).float(),
+                        "phase_pick": torch.from_numpy(phase_pick).float(),
+                        "event_location": event_location,
+                        "station_location": station_location,
+                    }
+
+
+
+def generate_label(phase_list, label_width=[150, 150], nt=8192):
+
+    target = np.zeros([len(phase_list) + 1, nt], dtype=np.float32)
+
+    for i, (picks, w) in enumerate(zip(phase_list, label_width)):
+        for phase_time in picks:
+            t = np.arange(nt) - phase_time
+            gaussian = np.exp(-(t**2) / (2 * (w / 6) ** 2))
+            gaussian[gaussian < 0.1] = 0.0
+            target[i + 1, :] += gaussian
+
+    target[0:1, :] = np.maximum(0, 1 - np.sum(target[1:, :], axis=0, keepdims=True))
+
+    return target