update script

quakeflow_nc.py

@@ -29,10 +29,9 @@ import datasets
 # Find for instance the citation on arxiv or on the dataset repo/website
 _CITATION = """\
 @InProceedings{huggingface:dataset,
-title = {A great new dataset},
-author={huggingface, Inc.
-},
-year={2020}
+title = {NCEDC dataset for QuakeFlow},
+author={Zhu et al.},
+year={2023}
 }
 """
 
@@ -52,9 +51,10 @@ _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"]
 _URLS = {
-    "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)],
+    "station": [f"{_REPO}/{x}" for f in _FILENAMES],
+    "event": [f"{_REPO}/{x}" for x in _FILENAMES],
 }
 
 class BatchBuilderConfig(datasets.BuilderConfig):
@@ -81,7 +81,6 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     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,
@@ -97,24 +96,24 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     
     # 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="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"),
+        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 = "NCEDC"  # 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=="NCEDC":
+        if self.config.name=="station":
             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'),
+                    "waveform": datasets.Array3D(shape=(3, self.nt), dtype='float32'),
+                    "phase_pick": datasets.Array3D(shape=(3, self.nt), dtype='float32'),
                     "event_location": datasets.Sequence(datasets.Value("float32")),
-                    "station_location": datasets.Array2D(shape=(self.num_stations, 3), dtype="float32"),
+                    "station_location": datasets.Sequence(datasets.Value("float32")),
                 })
             
-        elif self.config.name=="NCEDC_full_size":
+        elif self.config.name=="event":
             features=datasets.Features(
                 {
                     "waveform": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
@@ -157,7 +156,7 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                 name=datasets.Split.TRAIN,
                 # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": files,
+                    "filepath": files[:-1],
                     "split": "train",
                 },
             ),
@@ -169,14 +168,14 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             #         "split": "dev",
             #     },
             # ),
-            # datasets.SplitGenerator(
-            #     name=datasets.Split.TEST,
-            #     # These kwargs will be passed to _generate_examples
-            #     gen_kwargs={
-            #         "filepath": os.path.join(data_dir, "test.jsonl"),
-            #         "split": "test"
-            #     },
-            # ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": files[-1:],
+                    "split": "test"
+                },
+            ),
         ]
         
    
@@ -185,55 +184,55 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
     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 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"]]
+
+                        for i, sta_id in enumerate(station_ids):
+                            waveforms[:, :self.nt] = 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[:, :self.nt] = generate_label([p_picks, s_picks], nt=self.nt)
+                            station_location = [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"]/1e3]
+
+                            yield f"{event_id}/{sta_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=="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"]]
+                        station_location = []
                     
-                    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
-                    event_location = [attrs["longitude"], attrs["latitude"], attrs["depth_km"], attrs["event_time_index"]]
-                    station_location = []
-                    
-                    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])
+                        for i, sta_id in enumerate(station_ids):
+                            waveforms[i, :, :self.nt] = 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)
-                    std[std == 0] = 1.0
-                    waveforms = (waveforms - np.mean(waveforms, axis=1, keepdims=True)) / std
-                    waveforms = waveforms.astype(np.float32)
-                    
-                    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):