add batched configuration

README.md

@@ -76,36 +76,63 @@ Group: / len:10000
 - torch (for PyTorch)
 
 ### Usage
+Import the necessary packages:
 ```python
 import h5py
 import numpy as np
 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
+- `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
+
+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 default configuration is `NCEDC`. 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
-quakeflow_nc = datasets.load_dataset("AI4EPS/quakeflow_nc", split="train")
-quakeflow_nc
+
+# to load "NCEDC"
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", split="train")
+# or
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC", split="train")
+
+# to load "NCEDC_full_size"
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC_full_size", 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 below:
+
+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:
+Then you can use the dataset like this (Don't forget to specify the argument `name`):
 ```python
-quakeflow_nc = datasets.load_dataset("./quakeflow_nc.py", split="train")
+# 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`
 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 = 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()})
@@ -130,4 +157,50 @@ for batch in dataloader:
     for key in batch.keys():
         print(key, batch[key].shape, batch[key].dtype)
     break
+```
+
+#### Usage for `NCEDC_full_size`
+
+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")
+
+# 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("\nIterable test\n")
+    print(batch.keys())
+    for key in batch.keys():
+        print(key, batch[key].shape, batch[key].dtype)
+    break
+
+for batch in data_loader:
+    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

@@ -17,14 +17,9 @@
 """QuakeFlow_NC: A dataset of earthquake waveforms organized by earthquake events and based on the HDF5 format."""
 
 
-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
@@ -58,16 +53,36 @@ _LICENSE = ""
 # 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"
 _URLS = {
-    "NCEDC": [f"{_REPO}/ncedc_event_dataset_{i:03d}.h5" for i in range(37)]
+    "NCEDC": [f"{_REPO}/ncedc_event_dataset_{i:03d}.h5" for i in range(37)],
+    "NCEDC_full_size": [f"{_REPO}/ncedc_event_dataset_{i:03d}.h5" for i in range(37)],
 }
 
+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):
+        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
 class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     """QuakeFlow_NC: A dataset of earthquake waveforms organized by earthquake events and based on the HDF5 format."""
-
+    
     VERSION = datasets.Version("1.1.0")
 
+    degree2km = 111.32
+    nt = 8192
+    feature_nt = 512
+    feature_scale = int(nt / feature_nt)
+    sampling_rate=100.0
+    num_stations = 10
+    
     # This is an example of a dataset with multiple configurations.
     # If you don't want/need to define several sub-sets in your dataset,
     # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
@@ -79,22 +94,36 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     # You will be able to load one or the other configurations in the following list with
     # data = datasets.load_dataset('my_dataset', 'first_domain')
     # data = datasets.load_dataset('my_dataset', 'second_domain')
+    
+    # default config, you can change batch_size and num_stations_list when use `datasets.load_dataset`
     BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="NCEDC", version=VERSION, description="This part of my dataset covers a first domain"),
+        datasets.BuilderConfig(name="NCEDC", version=VERSION, description="yield event-based samples one by one, the number of sample stations is fixed(default: 10)"),
+        datasets.BuilderConfig(name="NCEDC_full_size", version=VERSION, description="yield event-based samples one by one, the number of sample stations is the same as the number of stations in the event"),
     ]
 
     DEFAULT_CONFIG_NAME = "NCEDC"  # It's not mandatory to have a default configuration. Just use one if it make sense.
 
     def _info(self):
         # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
-        features=datasets.Features(
-            {
-                "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"),
-            }
-        )
+        if self.config.name=="NCEDC":
+            features=datasets.Features(
+                {
+                    "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.Sequence(datasets.Value("float32")),
+                    "station_location": datasets.Array2D(shape=(self.num_stations, 3), dtype="float32"),
+                })
+            
+        elif self.config.name=="NCEDC_full_size":
+            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")),
+                    "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,
@@ -150,30 +179,26 @@ 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 fp.keys():
                     event = fp[event_id]
                     station_ids = list(event.keys())
-                    if len(station_ids) < num_stations:
-                        continue
-                    else:
-                        station_ids = np.random.choice(station_ids, num_stations, replace=False)
-                        
+                    
+                    if self.config.name=="NCEDC":
+                        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
@@ -182,13 +207,11 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     
                     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)
@@ -196,13 +219,21 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     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,
-                    }
-
+                    if self.config.name=="NCEDC":
+                        yield event_id, {
+                            "waveform": 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=="NCEDC_full_size":
+                        
+                        yield event_id, {
+                            "waveform": torch.from_numpy(waveforms).float().permute(2,0,1),
+                            "phase_pick": torch.from_numpy(phase_pick).float().permute(2,0,1),
+                            "event_location": torch.from_numpy(np.array(event_location)).float(),
+                            "station_location": torch.from_numpy(np.array(station_location)).float(),
+                        }
 
 
 def generate_label(phase_list, label_width=[150, 150], nt=8192):