Merge branch 'main' of hf.co:datasets/AI4EPS/quakeflow_nc

README.md

@@ -66,7 +66,7 @@ Waveform data, metadata, or data products for this study were accessed through t
 - datasets
 - h5py
 - fsspec
-- torch (for PyTorch)
+- pytorch
 
 ### Usage
 Import the necessary packages:
@@ -74,7 +74,6 @@ Import the necessary packages:
 import h5py
 import numpy as np
 import torch
-from torch.utils.data import Dataset, IterableDataset, DataLoader
 from datasets import load_dataset
 ```
 We have 6 configurations for the dataset: 
@@ -89,16 +88,28 @@ We have 6 configurations for the dataset:
 
 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
+- `begin_time`: the begin time of the waveform data
+- `end_time`: the end time of the waveform data
+- `phase_time`: the phase arrival time
+- `phase_index`: the time point index of the phase arrival time
+- `phase_type`: the phase type
+- `phase_polarity`: the phase polarity in ('U', 'D', 'N')
+- `event_time`: the event time
+- `event_time_index`: the time point index of the event time
+- `event_location`: the event location with shape `(3,)`, including latitude, longitude, depth
 - `station_location`: the station location with shape `(3,)`, including 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)`
+- `begin_time`: the begin time of the waveform data
+- `end_time`: the end time of the waveform data
+- `phase_time`: the phase arrival time with shape `(n_station,)`
+- `phase_index`: the time point index of the phase arrival time with shape `(n_station,)`
+- `phase_type`: the phase type with shape `(n_station,)`
+- `phase_polarity`: the phase polarity in ('U', 'D', 'N') with shape `(n_station,)`
+- `event_time`: the event time
+- `event_time_index`: the time point index of the event time
+- `event_location`: the space-time coordinates of the event with shape `(n_staion, 3)`
 - `station_location`: the space coordinates of the station with shape `(n_station, 3)`, including latitude, longitude and depth
 
 The default configuration is `station_test`. You can specify the configuration by argument `name`. For example:
@@ -117,70 +128,33 @@ quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="station_test", split="t
 quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="event", split="train")
 ```
 
-#### Usage for `station`
-Then you can change the dataset into PyTorch format iterable dataset, and view the first sample:
+#### Example loading the dataset
 ```python
 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 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)
-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)
+        if key == "data":
+            print(key, np.array(example[key]).shape)
+        else:
+            print(key, example[key])
     break
 
-dataloader = DataLoader(quakeflow_nc, batch_size=4, num_workers=num_workers)
+# %%
+quakeflow_nc = quakeflow_nc.with_format("torch")
+dataloader = DataLoader(quakeflow_nc, batch_size=8, num_workers=0, collate_fn=lambda x: x)
 
 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
-```
-
-#### 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="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)
-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=1, num_workers=num_workers)
-
-for batch in dataloader:
-    print("\nDataloader test\n")
-    print(batch.keys())
-    for key in batch.keys():
-        print(key, batch[key].shape, batch[key].dtype)
+    print(f"Batch size: {len(batch)}")
+    print(batch[0].keys())
+    for key in batch[0].keys():
+        if key == "data":
+            print(key, np.array(batch[0][key]).shape)
+        else:
+            print(key, batch[0][key])
     break
 ```

example.py

@@ -0,0 +1,41 @@
+# %%
+import numpy as np
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+
+# quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="station_test", split="test")
+quakeflow_nc = load_dataset(
+    "./quakeflow_nc.py",
+    name="station_test",
+    # name="event_test",
+    split="test",
+    download_mode="force_redownload",
+)
+
+# 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():
+        if key == "data":
+            print(key, np.array(example[key]).shape)
+        else:
+            print(key, example[key])
+    break
+
+# %%
+quakeflow_nc = quakeflow_nc.with_format("torch")
+dataloader = DataLoader(quakeflow_nc, batch_size=8, num_workers=0, collate_fn=lambda x: x)
+
+for batch in dataloader:
+    print("\nDataloader test\n")
+    print(f"Batch size: {len(batch)}")
+    print(batch[0].keys())
+    for key in batch[0].keys():
+        if key == "data":
+            print(key, np.array(batch[0][key]).shape)
+        else:
+            print(key, batch[0][key])
+    break
+
+# %%

quakeflow_nc.py

@@ -50,7 +50,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/waveform_ps_h5"
+_REPO = "https://huggingface.co/datasets/AI4EPS/quakeflow_nc/resolve/main/waveform_h5"
 _FILES = [
     "1987.h5",
     "1988.h5",
@@ -104,14 +104,10 @@ class BatchBuilderConfig(datasets.BuilderConfig):
     """
     yield a batch of event-based sample, so the number of sample stations can vary among batches
     Batch Config for QuakeFlow_NC
-    :param batch_size: number of samples in a batch
-    :param num_stations_list: possible number of stations in a batch
     """
 
-    def __init__(self, batch_size: int, num_stations_list: List, **kwargs):
+    def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.batch_size = batch_size
-        self.num_stations_list = num_stations_list
 
 
 # TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
@@ -172,13 +168,14 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             features = datasets.Features(
                 {
                     "data": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
-                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
                     "phase_time": datasets.Sequence(datasets.Value("string")),
                     "phase_index": datasets.Sequence(datasets.Value("int32")),
                     "phase_type": datasets.Sequence(datasets.Value("string")),
                     "phase_polarity": datasets.Sequence(datasets.Value("string")),
                     "begin_time": datasets.Value("string"),
                     "end_time": datasets.Value("string"),
+                    "event_time": datasets.Value("string"),
+                    "event_time_index": datasets.Value("int32"),
                     "event_location": datasets.Sequence(datasets.Value("float32")),
                     "station_location": datasets.Sequence(datasets.Value("float32")),
                 },
@@ -186,18 +183,21 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
         elif (self.config.name == "event") or (self.config.name == "event_train") or (self.config.name == "event_test"):
             features = datasets.Features(
                 {
-                    "data": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
-                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
-                    "phase_time": datasets.Sequence(datasets.Value("string")),
-                    "phase_index": datasets.Sequence(datasets.Value("int32")),
-                    "phase_type": datasets.Sequence(datasets.Value("string")),
-                    "phase_polarity": datasets.Sequence(datasets.Value("string")),
+                    "data": datasets.Array3D(shape=(None, 3, self.nt), dtype="float32"),
+                    "phase_time": datasets.Sequence(datasets.Sequence(datasets.Value("string"))),
+                    "phase_index": datasets.Sequence(datasets.Sequence(datasets.Value("int32"))),
+                    "phase_type": datasets.Sequence(datasets.Sequence(datasets.Value("string"))),
+                    "phase_polarity": datasets.Sequence(datasets.Sequence(datasets.Value("string"))),
                     "begin_time": datasets.Value("string"),
                     "end_time": datasets.Value("string"),
+                    "event_time": datasets.Value("string"),
+                    "event_time_index": datasets.Value("int32"),
                     "event_location": datasets.Sequence(datasets.Value("float32")),
-                    "station_location": datasets.Sequence(datasets.Value("float32")),
+                    "station_location": datasets.Sequence(datasets.Sequence(datasets.Value("float32"))),
                 },
             )
+        else:
+            raise ValueError(f"config.name = {self.config.name} is not in BUILDER_CONFIGS")
 
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
@@ -224,7 +224,8 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
         # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
         urls = _URLS[self.config.name]
         # files = dl_manager.download(urls)
-        files = dl_manager.download_and_extract(urls)
+        # files = dl_manager.download_and_extract(urls)
+        files = ["waveform_h5/1989.h5", "waveform_h5/1990.h5"]
         print(files)
 
         if self.config.name == "station" or self.config.name == "event":
@@ -280,9 +281,12 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                             event_attrs["longitude"],
                             event_attrs["latitude"],
                             event_attrs["depth_km"],
-                            event_attrs["event_time_index"],
                         ]
+                        event_time = event_attrs["event_time"]
+                        event_time_index = event_attrs["event_time_index"]
                         station_ids = list(event.keys())
+                        if len(station_ids) == 0:
+                            continue
                         if (
                             (self.config.name == "station")
                             or (self.config.name == "station_train")
@@ -307,6 +311,8 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                                     "phase_polarity": phase_polarity,
                                     "begin_time": begin_time,
                                     "end_time": end_time,
+                                    "event_time": event_time,
+                                    "event_time_index": event_time_index,
                                     "event_location": event_location,
                                     "station_location": station_location,
                                 }
@@ -327,14 +333,13 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                             for i, sta_id in enumerate(station_ids):
                                 waveforms[i, :, : self.nt] = event[sta_id][:, : self.nt]
                                 attrs = event[sta_id].attrs
-                                phase_type.append(attrs["phase_type"])
-                                phase_time.append(attrs["phase_time"])
-                                phase_index.append(attrs["phase_index"])
-                                phase_polarity.append(attrs["phase_polarity"])
+                                phase_type.append(list(attrs["phase_type"]))
+                                phase_time.append(list(attrs["phase_time"]))
+                                phase_index.append(list(attrs["phase_index"]))
+                                phase_polarity.append(list(attrs["phase_polarity"]))
                                 station_location.append(
                                     [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
                                 )
-
                             yield event_id, {
                                 "data": waveforms,
                                 "phase_time": phase_time,
@@ -343,6 +348,8 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                                 "phase_polarity": phase_polarity,
                                 "begin_time": begin_time,
                                 "end_time": end_time,
+                                "event_time": event_time,
+                                "event_time_index": event_time_index,
                                 "event_location": event_location,
                                 "station_location": station_location,
                             }