update EQNet event example generator and readme

README.md

@@ -5,7 +5,7 @@ license: mit
 # Quakeflow_NC
 
 ## Introduction
-This dataset is part of the data from [NCEDC (Northern California Earthquake Data Center)](https://ncedc.org/index.html) and is organized 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/))
+This dataset is part of the data (1970-2020) from [NCEDC (Northern California Earthquake Data Center)](https://ncedc.org/index.html) and is organized as several HDF5 files. The dataset structure is shown below, and you can find more information about the format at [AI4EPS](https://ai4eps.github.io/homepage/ml4earth/seismic_event_format1/))
 
 Cite the NCEDC:
 "NCEDC (2014), Northern California Earthquake Data Center. UC Berkeley Seismological Laboratory. Dataset. doi:10.7932/NCEDC."
@@ -14,63 +14,45 @@ Acknowledge the NCEDC:
 "Waveform data, metadata, or data products for this study were accessed through the Northern California Earthquake Data Center (NCEDC), doi:10.7932/NCEDC."
 
 ```
-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
+ Group: / len:16227
+  |- Group: /nc71111584 len:2
+  |  |-* begin_time = 2020-01-02T07:01:19.620
+  |  |-* depth_km = 3.69
+  |  |-* end_time = 2020-01-02T07:03:19.620
+  |  |-* event_id = nc71111584
+  |  |-* event_time = 2020-01-02T07:01:48.240
+  |  |-* event_time_index = 2862
+  |  |-* latitude = 37.6545
+  |  |-* longitude = -118.8798
+  |  |-* magnitude = -0.15
   |  |-* magnitude_type = D
-  |  |-* num_stations = 5
-  |  |- Dataset: /nc100012/NC.MRS..EH (shape:(3, 12000))
+  |  |-* num_stations = 2
+  |  |- Dataset: /nc71111584/NC.MCB..HH (shape:(3, 12000))
   |  |  |- (dtype=float32)
-  |  |  |  |-* azimuth = 265.0
-  |  |  |  |-* component = ['Z']
-  |  |  |  |-* distance_km = 39.1
+  |  |  |  |-* azimuth = 233.0
+  |  |  |  |-* component = ['E' 'N' 'Z']
+  |  |  |  |-* distance_km = 1.9
   |  |  |  |-* dt_s = 0.01
-  |  |  |  |-* elevation_m = 3680.0
-  |  |  |  |-* emergence_angle = 93.0
-  |  |  |  |-* event_id = ['nc100012' 'nc100012']
-  |  |  |  |-* latitude = 37.5107
+  |  |  |  |-* elevation_m = 2391.0
+  |  |  |  |-* emergence_angle = 159.0
+  |  |  |  |-* event_id = ['nc71111584' 'nc71111584']
+  |  |  |  |-* latitude = 37.6444
   |  |  |  |-* location = 
-  |  |  |  |-* longitude = -118.8822
+  |  |  |  |-* longitude = -118.8968
   |  |  |  |-* network = NC
-  |  |  |  |-* phase_index = [3274 3802]
+  |  |  |  |-* phase_index = [3000 3101]
   |  |  |  |-* 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_remark = ['IP' 'ES']
+  |  |  |  |-* phase_score = [1 2]
+  |  |  |  |-* phase_time = ['2020-01-02T07:01:49.620' '2020-01-02T07:01:50.630']
   |  |  |  |-* phase_type = ['P' 'S']
-  |  |  |  |-* snr = [0.         0.         1.98844361]
-  |  |  |  |-* station = MRS
+  |  |  |  |-* snr = [2.82143   3.055604  1.8412642]
+  |  |  |  |-* station = MCB
   |  |  |  |-* unit = 1e-6m/s
-  |  |- Dataset: /nc100012/NN.BEN.N1.EH (shape:(3, 12000))
+  |  |- Dataset: /nc71111584/NC.MCB..HN (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
+  |  |  |  |-* azimuth = 233.0
+  |  |  |  |-* component = ['E' 'N' 'Z']
   ......
   ```
 
@@ -79,6 +61,7 @@ Group: / len:10000
 ### Requirements
 - datasets
 - h5py
+- fsspec
 - torch (for PyTorch)
 
 ### Usage
@@ -90,57 +73,57 @@ import torch
 from torch.utils.data import Dataset, IterableDataset, DataLoader
 from datasets import load_dataset
 ```
-We have 2 configurations for the dataset: `NCEDC` and `NCEDC_full_size`. They all return event-based samples one by one. But `NCEDC` returns samples with 10 stations each, while `NCEDC_full_size` return samples with stations same as the original data.
-
-The sample of `NCEDC` is a dictionary with the following keys:
-- `waveform`: the waveform with shape `(3, nt, n_sta)`, the first dimension is 3 components, the second dimension is the number of time samples, the third dimension is the number of stations
-- `phase_pick`: the probability of the phase pick with shape `(3, nt, n_sta)`, the first dimension is noise, P and S
+We have 6 configurations for the dataset: 
+- "station"
+- "event"
+- "station_train"
+- "event_train"
+- "station_test"
+- "event_test"
+
+"station" yields station-based samples one by one, while "event" yields event-based samples one by one. The configurations with no suffix are the full dataset, while the configurations with suffix "_train" and "_test" only have corresponding split of the full dataset. Train split contains data from 1970 to 2019, while test split contains data in 2020.
+
+The sample of `station` is a dictionary with the following keys:
+- `data`: the waveform with shape `(3, nt)`, the default time length is 8192
+- `phase_pick`: the probability of the phase pick with shape `(3, nt)`, the first dimension is noise, P and S
 - `event_location`: the event location with shape `(4,)`, including latitude, longitude, depth and time
-- `station_location`: the station location with shape `(n_sta, 3)`, the first dimension is latitude, longitude and depth
+- `station_location`: the station location with shape `(3,)`, including latitude, longitude and depth
 
-Because Huggingface datasets only support dynamic size on first dimension, so the sample of `NCEDC_full_size` is a dictionary with the following keys:
-- `waveform`: the waveform with shape `(n_sta, 3, nt)`, 
-- `phase_pick`: the probability of the phase pick with shape `(n_sta, 3, nt)`
-- `event_location`: the event location with shape `(4,)`
-- `station_location`: the station location with shape `(n_sta, 3)`, the first dimension is latitude, longitude and depth
+The sample of `event` is a dictionary with the following keys:
+- `data`: the waveform with shape `(n_station, 3, nt)`, the default time length is 8192
+- `phase_pick`: the probability of the phase pick with shape `(n_station, 3, nt)`, the first dimension is noise, P and S
+- `event_center`: the probability of the event time with shape `(n_station, feature_nt)`, default feature time length is 512
+- `event_location`: the space-time coordinates of the event with shape `(n_staion, 4, feature_nt)`
+- `event_location_mask`: the probability mask of the event time with shape `(n_station, feature_nt)`
+- `station_location`: the space coordinates of the station with shape `(n_station, 3)`, including latitude, longitude and depth
 
-The default configuration is `NCEDC`. You can specify the configuration by argument `name`. For example:
+The default configuration is `station_test`. You can specify the configuration by argument `name`. For example:
 ```python
 # 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
 
-# to load "NCEDC"
-quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", split="train")
+# to load "station_test" with test split
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", split="test")
 # or
-quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC", split="train")
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="station_test", split="test")
 
-# to load "NCEDC_full_size"
-quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC_full_size", split="train")
+# to load "event" with train split
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="event", split="train")
 ```
 
-If you want to use the first several shards of the dataset, you can download the script `quakeflow_nc.py` and change the code as 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 (Don't forget to specify the argument `name`):
-```python
-# don't forget to specify the script path
-quakeflow_nc = datasets.load_dataset("path_to_script/quakeflow_nc.py", split="train")
-quakeflow_nc
-```
-
-#### Usage for `NCEDC`
+#### Usage for `station`
 Then you can change the dataset into PyTorch format iterable dataset, and view the first sample:
 ```python
-quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC", split="train")
-quakeflow_nc = quakeflow_nc.to_iterable_dataset()
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="station_test", split="test")
+# for PyTorch DataLoader, we need to divide the dataset into several shards
+num_workers=4
+quakeflow_nc = quakeflow_nc.to_iterable_dataset(num_shards=num_workers)
 # because add examples formatting to get tensors when using the "torch" format
-# has not been implemented yet, we need to manually add the formatting
+# has not been implemented yet, we need to manually add the formatting when using iterable dataset
+# if you want to use dataset directly, just use
+# quakeflow_nc.with_format("torch")
 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)
@@ -155,7 +138,7 @@ for example in quakeflow_nc:
         print(key, example[key].shape, example[key].dtype)
     break
 
-dataloader = DataLoader(quakeflow_nc, batch_size=4)
+dataloader = DataLoader(quakeflow_nc, batch_size=4, num_workers=num_workers)
 
 for batch in dataloader:
     print("\nDataloader test\n")
@@ -165,48 +148,35 @@ for batch in dataloader:
     break
 ```
 
-#### Usage for `NCEDC_full_size`
+#### Usage for `event`
 
 Then you can change the dataset into PyTorch format dataset, and view the first sample (Don't forget to reorder the keys):
 ```python
-quakeflow_nc = datasets.load_dataset("AI4EPS/quakeflow_nc", split="train", name="NCEDC_full_size")
+quakeflow_nc = datasets.load_dataset("AI4EPS/quakeflow_nc", split="test", name="event_test")
 
 # for PyTorch DataLoader, we need to divide the dataset into several shards
 num_workers=4
 quakeflow_nc = quakeflow_nc.to_iterable_dataset(num_shards=num_workers)
-# 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()})
-def reorder_keys(example):
-    example["waveform"] = example["waveform"].permute(1,2,0).contiguous()
-    example["phase_pick"] = example["phase_pick"].permute(1,2,0).contiguous()
-    return example
-    
-quakeflow_nc = quakeflow_nc.map(reorder_keys)
-
 try:
     isinstance(quakeflow_nc, torch.utils.data.IterableDataset)
 except:
     raise Exception("quakeflow_nc is not an IterableDataset")
 
-data_loader = DataLoader(
-    quakeflow_nc,
-    batch_size=1,
-    num_workers=num_workers,
-)
-
-for batch in quakeflow_nc:
+# print the first sample of the iterable dataset
+for example in quakeflow_nc:
     print("\nIterable test\n")
-    print(batch.keys())
-    for key in batch.keys():
-        print(key, batch[key].shape, batch[key].dtype)
+    print(example.keys())
+    for key in example.keys():
+        print(key, example[key].shape, example[key].dtype)
     break
 
-for batch in data_loader:
+dataloader = DataLoader(quakeflow_nc, batch_size=1, num_workers=num_workers)
+
+for batch in dataloader:
     print("\nDataloader test\n")
     print(batch.keys())
     for key in batch.keys():
-        batch[key] = batch[key].squeeze(0)
         print(key, batch[key].shape, batch[key].dtype)
     break
 ```

quakeflow_nc.py

@@ -153,25 +153,30 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             or (self.config.name == "station_train")
             or (self.config.name == "station_test")
         ):
-            features = datasets.Features(
+            features=datasets.Features(
                 {
-                    "waveform": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
-                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
+                    "data": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
+                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
                     "event_location": datasets.Sequence(datasets.Value("float32")),
                     "station_location": datasets.Sequence(datasets.Value("float32")),
-                }
-            )
-
-        elif (self.config.name == "event") or (self.config.name == "event_train") or (self.config.name == "event_test"):
-            features = datasets.Features(
+                })
+            
+        elif (
+            (self.config.name == "event") 
+            or (self.config.name == "event_train") 
+            or (self.config.name == "event_test")
+        ):
+            features=datasets.Features(
                 {
-                    "waveform": datasets.Array3D(shape=(None, 3, self.nt), dtype="float32"),
-                    "phase_pick": datasets.Array3D(shape=(None, 3, self.nt), dtype="float32"),
-                    "event_location": datasets.Sequence(datasets.Value("float32")),
+                    "data": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
+                    "phase_pick": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
+                    "event_center" : datasets.Array2D(shape=(None, self.feature_nt), dtype='float32'),
+                    "event_location": datasets.Array3D(shape=(None, 4, self.feature_nt), dtype='float32'),
+                    "event_location_mask": datasets.Array2D(shape=(None, self.feature_nt), dtype='float32'),
                     "station_location": datasets.Array2D(shape=(None, 3), dtype="float32"),
                 }
             )
-
+            
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -262,9 +267,9 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                                 attrs["depth_km"],
                                 attrs["event_time_index"],
                             ]
-
+                            
                             for i, sta_id in enumerate(station_ids):
-                                waveforms[:, : self.nt] = event[sta_id][:, : self.nt]
+                                waveforms[:, : self.nt] = event[sta_id][:, :self.nt]
                                 # waveforms[:, : self.nt] = event[sta_id][: self.nt, :].T
                                 attrs = event[sta_id].attrs
                                 p_picks = attrs["phase_index"][attrs["phase_type"] == "P"]
@@ -273,44 +278,111 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                                 station_location = [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
 
                                 yield f"{event_id}/{sta_id}", {
-                                    "waveform": torch.from_numpy(waveforms).float(),
+                                    "data": torch.from_numpy(waveforms).float(),
                                     "phase_pick": torch.from_numpy(phase_pick).float(),
                                     "event_location": torch.from_numpy(np.array(event_location)).float(),
                                     "station_location": torch.from_numpy(np.array(station_location)).float(),
                                 }
 
+
                         elif (
                             (self.config.name == "event")
                             or (self.config.name == "event_train")
                             or (self.config.name == "event_test")
                         ):
+                            event_attrs = event.attrs
+
+                            # avoid stations with P arrival equals S arrival
+                            is_sick = False
+                            for sta_id in station_ids:
+                                attrs = event[sta_id].attrs
+                                if attrs["phase_index"][attrs["phase_type"] == "P"] == attrs["phase_index"][attrs["phase_type"] == "S"]:
+                                    is_sick = True
+                                    break
+                            if is_sick:
+                                continue
+                            
                             waveforms = np.zeros([len(station_ids), 3, self.nt], dtype="float32")
                             phase_pick = np.zeros_like(waveforms)
-                            attrs = event.attrs
-                            event_location = [
-                                attrs["longitude"],
-                                attrs["latitude"],
-                                attrs["depth_km"],
-                                attrs["event_time_index"],
-                            ]
-                            station_location = []
+                            event_center = np.zeros([len(station_ids), self.nt])
+                            event_location = np.zeros([len(station_ids), 4, self.nt])
+                            event_location_mask = np.zeros([len(station_ids), self.nt])
+                            station_location = np.zeros([len(station_ids), 3])
 
                             for i, sta_id in enumerate(station_ids):
-                                waveforms[i, :, : self.nt] = event[sta_id][:, : self.nt]
-                                # waveforms[i, :, : self.nt] = event[sta_id][: self.nt, :].T
+                                # 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]
+
+                                ## TODO: how to deal with multiple phases
+                                # center = (attrs["phase_index"][::2] + attrs["phase_index"][1::2])/2.0
+                                ## assuming only one event with both P and S picks
+                                c0 = ((p_picks) + (s_picks)) / 2.0 # phase center
+                                c0_width = ((s_picks - p_picks) * self.sampling_rate / 200.0).max() if p_picks!=s_picks else 50
+                                dx = round(
+                                    (event_attrs["longitude"] - attrs["longitude"])
+                                    * np.cos(np.radians(event_attrs["latitude"]))
+                                    * self.degree2km,
+                                    2,
                                 )
+                                dy = round(
+                                    (event_attrs["latitude"] - attrs["latitude"])
+                                    * self.degree2km,
+                                    2,
+                                )
+                                dz = round(
+                                    event_attrs["depth_km"] + attrs["elevation_m"] / 1e3,
+                                    2,
+                                )
+
+                                event_center[i, :] = generate_label(
+                                    [
+                                        # [c0 / self.feature_scale],
+                                        c0,
+                                    ],
+                                    label_width=[
+                                        c0_width,
+                                    ],
+                                    # label_width=[
+                                    #     10,
+                                    # ],
+                                    # nt=self.feature_nt,
+                                    nt=self.nt,
+                                )[1, :]
+                                mask = event_center[i, :] >= 0.5
+                                event_location[i, 0, :] = (
+                                    np.arange(self.nt) - event_attrs["event_time_index"]
+                                ) / self.sampling_rate
+                                # event_location[0, :, i] = (np.arange(self.feature_nt) - 3000 / self.feature_scale) / self.sampling_rate
+                                # print(event_location[i, 1:, mask].shape, event_location.shape, event_location[i][1:, mask].shape)
+                                event_location[i][1:, mask] = np.array([dx, dy, dz])[:, np.newaxis]
+                                event_location_mask[i, :] = mask
+
+                                ## station location
+                                station_location[i, 0] = round(
+                                    attrs["longitude"]
+                                    * np.cos(np.radians(attrs["latitude"]))
+                                    * self.degree2km,
+                                    2,
+                                )
+                                station_location[i, 1] = round(attrs["latitude"] * self.degree2km, 2)
+                                station_location[i, 2] =  round(-attrs["elevation_m"]/1e3, 2)
+
+                            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(),
+                                "data": torch.from_numpy(waveforms).float(),
                                 "phase_pick": torch.from_numpy(phase_pick).float(),
-                                "event_location": torch.from_numpy(np.array(event_location)).float(),
-                                "station_location": torch.from_numpy(np.array(station_location)).float(),
+                                "event_center": torch.from_numpy(event_center[:, ::self.feature_scale]).float(),
+                                "event_location": torch.from_numpy(event_location[:, :, ::self.feature_scale]).float(),
+                                "event_location_mask": torch.from_numpy(event_location_mask[:, ::self.feature_scale]).float(),
+                                "station_location": torch.from_numpy(station_location).float(),
                             }