fix output

quakeflow_nc.py

@@ -120,11 +120,7 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
 
     VERSION = datasets.Version("1.1.0")
 
-    degree2km = 111.32
     nt = 8192
-    feature_nt = 512
-    feature_scale = int(nt / feature_nt)
-    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,
@@ -173,30 +169,36 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
             or (self.config.name == "station_train")
             or (self.config.name == "station_test")
         ):
-            features=datasets.Features(
+            features = datasets.Features(
                 {
-                    "data": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
-                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype='float32'),
+                    "data": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
+                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
+                    "phase_time": datasets.Sequence(datasets.Value("string")),
+                    "phase_index": datasets.Sequence(datasets.Value("int32")),
+                    "phase_type": datasets.Sequence(datasets.Value("string")),
+                    "phase_polarity": datasets.Sequence(datasets.Value("string")),
+                    "begin_time": datasets.Value("string"),
+                    "end_time": datasets.Value("string"),
                     "event_location": datasets.Sequence(datasets.Value("float32")),
                     "station_location": datasets.Sequence(datasets.Value("float32")),
-                })
-            
-        elif (
-            (self.config.name == "event") 
-            or (self.config.name == "event_train") 
-            or (self.config.name == "event_test")
-        ):
-            features=datasets.Features(
+                },
+            )
+        elif (self.config.name == "event") or (self.config.name == "event_train") or (self.config.name == "event_test"):
+            features = datasets.Features(
                 {
-                    "data": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
-                    "phase_pick": datasets.Array3D(shape=(None, 3, self.nt), dtype='float32'),
-                    "event_center" : datasets.Array2D(shape=(None, self.feature_nt), dtype='float32'),
-                    "event_location": datasets.Array3D(shape=(None, 4, self.feature_nt), dtype='float32'),
-                    "event_location_mask": datasets.Array2D(shape=(None, self.feature_nt), dtype='float32'),
-                    "station_location": datasets.Array2D(shape=(None, 3), dtype="float32"),
-                }
+                    "data": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
+                    "phase_pick": datasets.Array2D(shape=(3, self.nt), dtype="float32"),
+                    "phase_time": datasets.Sequence(datasets.Value("string")),
+                    "phase_index": datasets.Sequence(datasets.Value("int32")),
+                    "phase_type": datasets.Sequence(datasets.Value("string")),
+                    "phase_polarity": datasets.Sequence(datasets.Value("string")),
+                    "begin_time": datasets.Value("string"),
+                    "end_time": datasets.Value("string"),
+                    "event_location": datasets.Sequence(datasets.Value("float32")),
+                    "station_location": datasets.Sequence(datasets.Value("float32")),
+                },
             )
-            
+
         return datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
@@ -268,10 +270,18 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
         for file in filepath:
             with fsspec.open(file, "rb") as fs:
                 with h5py.File(fs, "r") as fp:
-                    # for event_id in sorted(list(fp.keys())):
                     event_ids = list(fp.keys())
                     for event_id in event_ids:
                         event = fp[event_id]
+                        event_attrs = event.attrs
+                        begin_time = event_attrs["begin_time"]
+                        end_time = event_attrs["end_time"]
+                        event_location = [
+                            event_attrs["longitude"],
+                            event_attrs["latitude"],
+                            event_attrs["depth_km"],
+                            event_attrs["event_time_index"],
+                        ]
                         station_ids = list(event.keys())
                         if (
                             (self.config.name == "station")
@@ -279,143 +289,60 @@ class QuakeFlow_NC(datasets.GeneratorBasedBuilder):
                             or (self.config.name == "station_test")
                         ):
                             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]
-                                # waveforms[:, : self.nt] = event[sta_id][: self.nt, :].T
+                                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)
+                                phase_type = attrs["phase_type"]
+                                phase_time = attrs["phase_time"]
+                                phase_index = attrs["phase_index"]
+                                phase_polarity = attrs["phase_polarity"]
                                 station_location = [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
 
                                 yield f"{event_id}/{sta_id}", {
-                                    "data": 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(),
+                                    "data": waveforms,
+                                    "phase_time": phase_time,
+                                    "phase_index": phase_index,
+                                    "phase_type": phase_type,
+                                    "phase_polarity": phase_polarity,
+                                    "begin_time": begin_time,
+                                    "end_time": end_time,
+                                    "event_location": event_location,
+                                    "station_location": station_location,
                                 }
 
-
                         elif (
                             (self.config.name == "event")
                             or (self.config.name == "event_train")
                             or (self.config.name == "event_test")
                         ):
-                            event_attrs = event.attrs
 
-                            # avoid stations with P arrival equals S arrival
-                            is_sick = False
-                            for sta_id in station_ids:
-                                attrs = event[sta_id].attrs
-                                if attrs["phase_index"][attrs["phase_type"] == "P"] == attrs["phase_index"][attrs["phase_type"] == "S"]:
-                                    is_sick = True
-                                    break
-                            if is_sick:
-                                continue
-                            
                             waveforms = np.zeros([len(station_ids), 3, self.nt], dtype="float32")
-                            phase_pick = np.zeros_like(waveforms)
-                            event_center = np.zeros([len(station_ids), self.nt])
-                            event_location = np.zeros([len(station_ids), 4, self.nt])
-                            event_location_mask = np.zeros([len(station_ids), self.nt])
-                            station_location = np.zeros([len(station_ids), 3])
+                            phase_type = []
+                            phase_time = []
+                            phase_index = []
+                            phase_polarity = []
+                            station_location = []
 
                             for i, sta_id in enumerate(station_ids):
-                                # trace_id = event_id + "/" + sta_id
-                                waveforms[i, :, :] = event[sta_id][:, :self.nt]
+                                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)
-
-                                ## TODO: how to deal with multiple phases
-                                # center = (attrs["phase_index"][::2] + attrs["phase_index"][1::2])/2.0
-                                ## assuming only one event with both P and S picks
-                                c0 = ((p_picks) + (s_picks)) / 2.0 # phase center
-                                c0_width = ((s_picks - p_picks) * self.sampling_rate / 200.0).max() if p_picks!=s_picks else 50
-                                dx = round(
-                                    (event_attrs["longitude"] - attrs["longitude"])
-                                    * np.cos(np.radians(event_attrs["latitude"]))
-                                    * self.degree2km,
-                                    2,
-                                )
-                                dy = round(
-                                    (event_attrs["latitude"] - attrs["latitude"])
-                                    * self.degree2km,
-                                    2,
+                                phase_type.append(attrs["phase_type"])
+                                phase_time.append(attrs["phase_time"])
+                                phase_index.append(attrs["phase_index"])
+                                phase_polarity.append(attrs["phase_polarity"])
+                                station_location.append(
+                                    [attrs["longitude"], attrs["latitude"], -attrs["elevation_m"] / 1e3]
                                 )
-                                dz = round(
-                                    event_attrs["depth_km"] + attrs["elevation_m"] / 1e3,
-                                    2,
-                                )
-
-                                event_center[i, :] = generate_label(
-                                    [
-                                        # [c0 / self.feature_scale],
-                                        c0,
-                                    ],
-                                    label_width=[
-                                        c0_width,
-                                    ],
-                                    # label_width=[
-                                    #     10,
-                                    # ],
-                                    # nt=self.feature_nt,
-                                    nt=self.nt,
-                                )[1, :]
-                                mask = event_center[i, :] >= 0.5
-                                event_location[i, 0, :] = (
-                                    np.arange(self.nt) - event_attrs["event_time_index"]
-                                ) / self.sampling_rate
-                                # event_location[0, :, i] = (np.arange(self.feature_nt) - 3000 / self.feature_scale) / self.sampling_rate
-                                # print(event_location[i, 1:, mask].shape, event_location.shape, event_location[i][1:, mask].shape)
-                                event_location[i][1:, mask] = np.array([dx, dy, dz])[:, np.newaxis]
-                                event_location_mask[i, :] = mask
-
-                                ## station location
-                                station_location[i, 0] = round(
-                                    attrs["longitude"]
-                                    * np.cos(np.radians(attrs["latitude"]))
-                                    * self.degree2km,
-                                    2,
-                                )
-                                station_location[i, 1] = round(attrs["latitude"] * self.degree2km, 2)
-                                station_location[i, 2] =  round(-attrs["elevation_m"]/1e3, 2)
-
-                            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)
 
                             yield event_id, {
-                                "data": torch.from_numpy(waveforms).float(),
-                                "phase_pick": torch.from_numpy(phase_pick).float(),
-                                "event_center": torch.from_numpy(event_center[:, ::self.feature_scale]).float(),
-                                "event_location": torch.from_numpy(event_location[:, :, ::self.feature_scale]).float(),
-                                "event_location_mask": torch.from_numpy(event_location_mask[:, ::self.feature_scale]).float(),
-                                "station_location": torch.from_numpy(station_location).float(),
+                                "data": waveforms,
+                                "phase_time": phase_time,
+                                "phase_index": phase_index,
+                                "phase_type": phase_type,
+                                "phase_polarity": phase_polarity,
+                                "begin_time": begin_time,
+                                "end_time": end_time,
+                                "event_location": event_location,
+                                "station_location": station_location,
                             }
-
-
-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)):
-        for phase_time in picks:
-            t = np.arange(nt) - phase_time
-            gaussian = np.exp(-(t**2) / (2 * (w / 6) ** 2))
-            gaussian[gaussian < 0.1] = 0.0
-            target[i + 1, :] += gaussian
-
-    target[0:1, :] = np.maximum(0, 1 - np.sum(target[1:, :], axis=0, keepdims=True))
-
-    return target