add batched configuration

README.md

@@ -76,36 +76,49 @@ 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_Batch`. `NCEDC` return event-based samples(with 10 stations each) one by one, while `NCEDC_Batch` return event-based samples in specified batch size and specified stations number(default:`batch_size=16`,`num_stations_list=[5, 10, 20]`). 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_Batch"
+quakeflow_nc = load_dataset("AI4EPS/quakeflow_nc", name="NCEDC_Batch", 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 +143,51 @@ for batch in dataloader:
     for key in batch.keys():
         print(key, batch[key].shape, batch[key].dtype)
     break
+```
+
+#### Usage for `NCEDC_Batch`
+Then you can change the dataset into PyTorch format iterable dataset, and view the first sample:
+```python
+quakeflow_batch = datasets.load_dataset("AI4EPS/quakeflow_nc", split="train", name="NCEDC_Batch", batch_size=16, num_stations_list=[5,10,20])
+
+# for PyTorch DataLoader, we need to divide the dataset into several shards
+num_workers=4
+quakeflow_batch = quakeflow_batch.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_batch = quakeflow_batch.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,3,0).contiguous()
+    example["phase_pick"] = example["phase_pick"].permute(1,2,3,0).contiguous()
+    example["station_location"] = example["station_location"].permute(1,0,2).contiguous()
+    return example
+    
+quakeflow_batch = quakeflow_batch.map(reorder_keys)
+
+try:
+    isinstance(quakeflow_batch, torch.utils.data.IterableDataset)
+except:
+    raise Exception("quakeflow_nc is not an IterableDataset")
+
+data_loader = DataLoader(
+    quakeflow_batch,
+    sampler=None,
+    collate_fn=None,
+    num_workers=num_workers,
+)
+
+for batch in quakeflow_batch:
+    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

@@ -26,6 +26,7 @@ import torch
 import fsspec
 from glob import glob
 from typing import Dict, List, Optional, Tuple, Union
+from collections import defaultdict
 
 import datasets
 
@@ -58,14 +59,35 @@ _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_Batch": [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
+    #batch_size: int=None
+    #num_stations_list: List=None
 
 # 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."""
 
+    degree2km = 111.32
+    nt = 8192
+    feature_nt = 512
+    feature_scale = int(nt / feature_nt)
+    sampling_rate=100.0
+    num_stations = 10
+    
     VERSION = datasets.Version("1.1.0")
 
     # This is an example of a dataset with multiple configurations.
@@ -79,22 +101,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"),
+        BatchBuilderConfig(name="NCEDC", version=VERSION, description="yield event-based samples one by one, the", batch_size=1, num_stations_list=[num_stations]),
+        BatchBuilderConfig(name="NCEDC_Batch", version=VERSION, description="This part of my dataset covers a first domain", batch_size=16, num_stations_list=[5, 10, 20]),
     ]
 
-    DEFAULT_CONFIG_NAME = "NCEDC"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    DEFAULT_CONFIG_NAME = "NCEDC_Batch"  # 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_Batch":
+            features=datasets.Features(
+                {
+                    "waveform": datasets.Array4D(shape=(None, self.config.batch_size, 3, self.nt), dtype='float32'),# datasets.Array4D(shape=(self.config.batch_size, 3, self.nt, self.num_stations), dtype='float32'),
+                    "phase_pick": datasets.Array4D(shape=(None, self.config.batch_size, 3, self.nt), dtype='float32'),
+                    "event_location": datasets.Array2D(shape=(self.config.batch_size, 4), dtype="float32"),
+                    "station_location": datasets.Array3D(shape=(None, self.config.batch_size, 3), dtype="float32"),
+                }
+            )
+            
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -130,6 +166,8 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                 gen_kwargs={
                     "filepath": files,
                     "split": "train",
+                    "batch_size": self.config.batch_size,
+                    "num_stations_list": self.config.num_stations_list,
                 },
             ),
             # datasets.SplitGenerator(
@@ -150,18 +188,20 @@ 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):
+    def _generate_examples(self, filepath, split, batch_size, num_stations_list):
         # 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
+        num_batches = 0
+        
+        num_stations_list = np.array(num_stations_list)
+        if self.config.name=="NCEDC_Batch":
+            waveform_buffer_per_group = defaultdict(list)
+            phase_pick_buffer_per_group = defaultdict(list)
+            event_location_buffer_per_group = defaultdict(list)
+            station_location_buffer_per_group = defaultdict(list)
         
         for file in filepath:
             with h5py.File(file, "r") as fp:
@@ -169,11 +209,17 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                 for event_id in fp.keys():
                     event = fp[event_id]
                     station_ids = list(event.keys())
-                    if len(station_ids) < num_stations:
+                    
+                    if len(station_ids) < num_stations_list[0]:
                         continue
-                    else:
-                        station_ids = np.random.choice(station_ids, num_stations, replace=False)
-                        
+                    
+                    if batch_size==1 and self.config.name=="NCEDC":
+                        num_stations = num_stations_list[0]
+                    elif self.config.name=="NCEDC_Batch":
+                        num_stations=num_stations_list[num_stations_list<=len(station_ids)][-1]
+                    
+                    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 +228,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 +240,49 @@ 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 batch_size==1 and self.config.name=="NCEDC":
+                        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,
+                        }
+                    elif self.config.name=="NCEDC_Batch":
+                        
+                        waveform_buffer_per_group[num_stations].append(waveforms)
+                        phase_pick_buffer_per_group[num_stations].append(phase_pick)
+                        event_location_buffer_per_group[num_stations].append(event_location)
+                        station_location_buffer_per_group[num_stations].append(station_location)
+                        
+                        if len(waveform_buffer_per_group[num_stations])==batch_size:
+                            yield num_batches, {
+                                "waveform": torch.from_numpy(np.stack(waveform_buffer_per_group[num_stations], axis=0)).float().permute(3,0,1,2),
+                                "phase_pick": torch.from_numpy(np.stack(phase_pick_buffer_per_group[num_stations], axis=0)).float().permute(3,0,1,2),
+                                "event_location": torch.from_numpy(np.stack(event_location_buffer_per_group[num_stations], axis=0)).float(),
+                                "station_location": torch.from_numpy(np.stack(station_location_buffer_per_group[num_stations], axis=0)).float().permute(1,0,2),
+                            }
+                            del waveform_buffer_per_group[num_stations]
+                            del phase_pick_buffer_per_group[num_stations]
+                            del event_location_buffer_per_group[num_stations]
+                            del station_location_buffer_per_group[num_stations]
+                            num_batches += 1
+                        assert len(waveform_buffer_per_group[num_stations])<batch_size, "batch size is not correct"
+                            
+        '''
+        # drop_last=False                   
+        if self.config.name=="NCEDC_Batch":
+            for num_stations in waveform_buffer_per_group:
+                yield event_id, {
+                    "waveform": torch.from_numpy(np.stack(waveform_buffer_per_group, axis=0)).float(),
+                    "phase_pick": torch.from_numpy(np.stack(phase_pick_buffer_per_group, axis=0)).float(),
+                    "event_location": np.stack(event_location_buffer_per_group, axis=0),
+                    "station_location": np.stack(station_location_buffer_per_group, axis=0),
+                }
+                del waveform_buffer_per_group[num_stations]
+                del phase_pick_buffer_per_group[num_stations]
+                del event_location_buffer_per_group[num_stations]
+                del station_location_buffer_per_group[num_stations]
+        ''' 
 
 
 def generate_label(phase_list, label_width=[150, 150], nt=8192):