remove batched operation and leave it to sampler

README.md

@@ -84,7 +84,21 @@ 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:
+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
@@ -96,8 +110,8 @@ 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")
+# 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 as below:
@@ -145,38 +159,37 @@ for batch in dataloader:
     break
 ```
 
-#### Usage for `NCEDC_Batch`
-Then you can change the dataset into PyTorch format iterable dataset, and view the first sample:
+#### 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_batch = datasets.load_dataset("AI4EPS/quakeflow_nc", split="train", name="NCEDC_Batch", batch_size=16, num_stations_list=[5,10,20])
+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_batch = quakeflow_batch.to_iterable_dataset(num_shards=num_workers)
+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_batch = quakeflow_batch.map(lambda x: {key: torch.from_numpy(np.array(value, dtype=np.float32)) for key, value in x.items()})
+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,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()
+    example["waveform"] = example["waveform"].permute(1,2,0).contiguous()
+    example["phase_pick"] = example["phase_pick"].permute(1,2,0).contiguous()
     return example
     
-quakeflow_batch = quakeflow_batch.map(reorder_keys)
+quakeflow_nc = quakeflow_nc.map(reorder_keys)
 
 try:
-    isinstance(quakeflow_batch, torch.utils.data.IterableDataset)
+    isinstance(quakeflow_nc, torch.utils.data.IterableDataset)
 except:
     raise Exception("quakeflow_nc is not an IterableDataset")
 
 data_loader = DataLoader(
-    quakeflow_batch,
-    sampler=None,
-    collate_fn=None,
+    quakeflow_nc,
+    batch_size=1,
     num_workers=num_workers,
 )
 
-for batch in quakeflow_batch:
+for batch in quakeflow_nc:
     print("\nIterable test\n")
     print(batch.keys())
     for key in batch.keys():

quakeflow_nc.py

@@ -17,16 +17,10 @@
 """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
-from collections import defaultdict
 
 import datasets
 
@@ -60,7 +54,7 @@ _LICENSE = ""
 _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_Batch": [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):
@@ -74,12 +68,13 @@ class BatchBuilderConfig(datasets.BuilderConfig):
         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."""
+    
+    VERSION = datasets.Version("1.1.0")
 
     degree2km = 111.32
     nt = 8192
@@ -88,8 +83,6 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     sampling_rate=100.0
     num_stations = 10
     
-    VERSION = datasets.Version("1.1.0")
-
     # 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.
@@ -104,11 +97,11 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     
     # default config, you can change batch_size and num_stations_list when use `datasets.load_dataset`
     BUILDER_CONFIGS = [
-        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]),
+        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_Batch"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    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
@@ -121,13 +114,13 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     "station_location": datasets.Array2D(shape=(self.num_stations, 3), dtype="float32"),
                 })
             
-        elif self.config.name=="NCEDC_Batch":
+        elif self.config.name=="NCEDC_full_size":
             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"),
+                    "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"),
                 }
             )
             
@@ -166,8 +159,6 @@ 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(
@@ -191,18 +182,10 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
    
 
     # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
-    def _generate_examples(self, filepath, split, batch_size, num_stations_list):
+    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_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)
-        
+        num_stations = self.num_stations
         for file in filepath:
             with h5py.File(file, "r") as fp:
                 # for event_id in sorted(list(fp.keys())):
@@ -210,15 +193,11 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     event = fp[event_id]
                     station_ids = list(event.keys())
                     
-                    if len(station_ids) < num_stations_list[0]:
-                        continue
-                    
-                    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)
+                    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)
@@ -240,49 +219,21 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     waveforms = (waveforms - np.mean(waveforms, axis=1, keepdims=True)) / std
                     waveforms = waveforms.astype(np.float32)
                     
-                    if batch_size==1 and self.config.name=="NCEDC":
+                    if 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,
+                            "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_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)
+                    elif self.config.name=="NCEDC_full_size":
                         
-                        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]
-        ''' 
+                        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):