add data

quakeflow_nc.py

@@ -52,13 +52,31 @@ _LICENSE = ""
 # 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/data"
-_FILENAMES = ["NC1970-1989.h5", "NC1990-1994.h5", "NC1995-1999.h5", "NC2000-2004.h5", "NC2005-2009.h5", "NC2010.h5", "NC2011.h5", "NC2012.h5", "NC2013.h5", "NC2014.h5", "NC2015.h5", "NC2016.h5", "NC2017.h5", "NC2018.h5", "NC2019.h5", "NC2020.h5"]
+_FILENAMES = [
+    "NC1970-1989.h5",
+    "NC1990-1994.h5",
+    "NC1995-1999.h5",
+    "NC2000-2004.h5",
+    "NC2005-2009.h5",
+    "NC2010.h5",
+    "NC2011.h5",
+    "NC2012.h5",
+    "NC2013.h5",
+    "NC2014.h5",
+    "NC2015.h5",
+    "NC2016.h5",
+    "NC2017.h5",
+    "NC2018.h5",
+    "NC2019.h5",
+    "NC2020.h5",
+]
 # _FILENAMES = ["NC2020.h5"]
 _URLS = {
     "station": [f"{_REPO}/{x}" for x in _FILENAMES],
     "event": [f"{_REPO}/{x}" for x in _FILENAMES],
 }
 
+
 class BatchBuilderConfig(datasets.BuilderConfig):
     """
     yield a batch of event-based sample, so the number of sample stations can vary among batches
@@ -66,6 +84,7 @@ class BatchBuilderConfig(datasets.BuilderConfig):
     :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
@@ -75,15 +94,15 @@ class BatchBuilderConfig(datasets.BuilderConfig):
 # 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
-    
+    sampling_rate = 100.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.
@@ -95,36 +114,39 @@ 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="station", version=VERSION, description="yield station-based samples one by one"),
         datasets.BuilderConfig(name="event", version=VERSION, description="yield event-based samples one by one"),
     ]
 
-    DEFAULT_CONFIG_NAME = "station"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    DEFAULT_CONFIG_NAME = (
+        "station"  # 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
-        if self.config.name=="station":
-            features=datasets.Features(
+        if self.config.name == "station":
+            features = datasets.Features(
                 {
-                    "waveform": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
-                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
+                    "waveform": 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":
-            features=datasets.Features(
+                }
+            )
+
+        elif self.config.name == "event":
+            features = datasets.Features(
                 {
-                    "waveform": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
-                    "phase_pick": datasets.Array3D(shape=(None, 3, self.nt), 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"),
                 }
             )
-            
+
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -173,14 +195,9 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
                 # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": files[-1:],
-                    "split": "test"
-                },
+                gen_kwargs={"filepath": files[-1:], "split": "test"},
             ),
         ]
-        
-   
 
     # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
     def _generate_examples(self, filepath, split):
@@ -195,20 +212,25 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                     for event_id in event_ids:
                         event = fp[event_id]
                         station_ids = list(event.keys())
-                        if self.config.name=="station":
+                        if self.config.name == "station":
                             waveforms = np.zeros([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"]]
+                            event_location = [
+                                attrs["longitude"],
+                                attrs["latitude"],
+                                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,:].T
+                                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"]
                                 s_picks = attrs["phase_index"][attrs["phase_type"] == "S"]
                                 # phase_pick[:, :self.nt] = generate_label([p_picks, s_picks], nt=self.nt)
-                                station_location = [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"]/1e3]
+                                station_location = [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
 
                                 yield f"{event_id}/{sta_id}", {
                                     "waveform": torch.from_numpy(waveforms).float(),
@@ -217,22 +239,29 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                                     "station_location": torch.from_numpy(np.array(station_location)).float(),
                                 }
 
-                        elif self.config.name=="event":
+                        elif self.config.name == "event":
                             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"]]
+                            event_location = [
+                                attrs["longitude"],
+                                attrs["latitude"],
+                                attrs["depth_km"],
+                                attrs["event_time_index"],
+                            ]
                             station_location = []
-                        
+
                             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
+                                waveforms[i, :, : self.nt] = event[sta_id][:, : self.nt]
+                                # waveforms[i, :, : self.nt] = event[sta_id][: self.nt, :].T
                                 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])
-                            
+                                station_location.append(
+                                    [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
+                                )
+
                             yield event_id, {
                                 "waveform": torch.from_numpy(waveforms).float(),
                                 "phase_pick": torch.from_numpy(phase_pick).float(),
@@ -242,7 +271,6 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
 
 
 def generate_label(phase_list, label_width=[150, 150], nt=8192):
-
     target = np.zeros([len(phase_list) + 1, nt], dtype=np.float32)
 
     for i, (picks, w) in enumerate(zip(phase_list, label_width)):
@@ -254,4 +282,4 @@ def generate_label(phase_list, label_width=[150, 150], nt=8192):
 
     target[0:1, :] = np.maximum(0, 1 - np.sum(target[1:, :], axis=0, keepdims=True))
 
-    return target
+    return target