add requirements and initial setup for TTSAM intensity prediction system

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mseed filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,7 +1,559 @@
 import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from obspy import read
+from datasets import load_dataset
+import xarray as xr
+import torch
+import torch.nn as nn
+from scipy.signal import detrend, iirfilter, sosfilt, zpk2sos
+from scipy.spatial import cKDTree
+import pandas as pd
+from loguru import logger
 
-def greet(name):
-    return "Hello " + name + "!!"
+# GPU/CPU 設定
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+    logger.info("使用 GPU")
+else:
+    device = torch.device("cpu")
+    logger.info("使用 CPU")
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# 載入 Vs30 資料集（從 Hugging Face 下載）
+from huggingface_hub import hf_hub_download
+
+try:
+    logger.info("從 Hugging Face 載入 Vs30 資料...")
+    vs30_file = hf_hub_download(
+        repo_id="SeisBlue/TaiwanVs30",
+        filename="Vs30ofTaiwan.nc"
+    )
+    ds = xr.open_dataset(vs30_file)
+    lat_flat = ds['lat'].values.flatten()
+    lon_flat = ds['lon'].values.flatten()
+    vs30_flat = ds['vs30'].values.flatten()
+
+    vs30_table = pd.DataFrame({'lat': lat_flat, 'lon': lon_flat, 'Vs30': vs30_flat})
+    vs30_table = vs30_table.replace([np.inf, -np.inf], np.nan).dropna()
+    tree = cKDTree(vs30_table[["lat", "lon"]])
+    logger.info("Vs30 資料載入完成")
+except Exception as e:
+    logger.error(f"Vs30 資料載入失敗: {e}")
+
+# 載入目標測站
+target_file = "station/eew_target.csv"
+try:
+    logger.info(f"載入 {target_file}...")
+    target_df = pd.read_csv(target_file)
+    target_dict = target_df.to_dict(orient="records")
+    logger.info(f"{target_file} 載入完成")
+except FileNotFoundError:
+    logger.error(f"{target_file} 找不到")
+
+# 載入測站資訊
+site_info_file = "station/site_info.txt"
+try:
+    logger.info(f"載入 {site_info_file}...")
+    site_info = pd.read_csv(site_info_file)
+    logger.info(f"{site_info_file} 載入完成")
+except FileNotFoundError:
+    logger.warning(f"{site_info_file} 找不到")
+
+# 預設地震事件
+EARTHQUAKE_EVENTS = {
+    "0403花蓮地震 (2024)": "waveform/20240403.mseed",
+}
+
+
+# ============ 模型定義（從 ttsam_realtime.py 複製） ============
+
+class LambdaLayer(nn.Module):
+    def __init__(self, lambd, eps=1e-4):
+        super(LambdaLayer, self).__init__()
+        self.lambd = lambd
+        self.eps = eps
+
+    def forward(self, x):
+        return self.lambd(x) + self.eps
+
+
+class MLP(nn.Module):
+    def __init__(self, input_shape, dims=(500, 300, 200, 150), activation=nn.ReLU(),
+                 last_activation=None):
+        super(MLP, self).__init__()
+        if last_activation is None:
+            last_activation = activation
+        self.dims = dims
+        self.first_fc = nn.Linear(input_shape[0], dims[0])
+        self.first_activation = activation
+
+        more_hidden = []
+        if len(self.dims) > 2:
+            for i in range(1, len(self.dims) - 1):
+                more_hidden.append(nn.Linear(self.dims[i - 1], self.dims[i]))
+                more_hidden.append(nn.ReLU())
+
+        self.more_hidden = nn.ModuleList(more_hidden)
+        self.last_fc = nn.Linear(dims[-2], dims[-1])
+        self.last_activation = last_activation
+
+    def forward(self, x):
+        output = self.first_fc(x)
+        output = self.first_activation(output)
+        if self.more_hidden:
+            for layer in self.more_hidden:
+                output = layer(output)
+        output = self.last_fc(output)
+        output = self.last_activation(output)
+        return output
+
+
+class CNN(nn.Module):
+    def __init__(self, input_shape=(-1, 6000, 3), activation=nn.ReLU(), downsample=1,
+                 mlp_input=11665, mlp_dims=(500, 300, 200, 150), eps=1e-8):
+        super(CNN, self).__init__()
+        self.input_shape = input_shape
+        self.activation = activation
+        self.downsample = downsample
+        self.mlp_input = mlp_input
+        self.mlp_dims = mlp_dims
+        self.eps = eps
+
+        self.lambda_layer_1 = LambdaLayer(
+            lambda t: t / (
+                        torch.max(torch.max(torch.abs(t), dim=1, keepdim=True).values,
+                                  dim=2, keepdim=True).values + self.eps)
+        )
+        self.unsqueeze_layer1 = LambdaLayer(lambda t: torch.unsqueeze(t, dim=1))
+        self.lambda_layer_2 = LambdaLayer(
+            lambda t: torch.log(torch.max(torch.max(torch.abs(t), dim=1).values,
+                                          dim=1).values + self.eps) / 100
+        )
+        self.unsqueeze_layer2 = LambdaLayer(lambda t: torch.unsqueeze(t, dim=1))
+        self.conv2d1 = nn.Sequential(
+            nn.Conv2d(1, 8, kernel_size=(1, downsample), stride=(1, downsample)),
+            nn.ReLU())
+        self.conv2d2 = nn.Sequential(
+            nn.Conv2d(8, 32, kernel_size=(16, 3), stride=(1, 3)), nn.ReLU())
+        self.conv1d1 = nn.Sequential(nn.Conv1d(32, 64, kernel_size=16), nn.ReLU())
+        self.maxpooling = nn.MaxPool1d(2)
+        self.conv1d2 = nn.Sequential(nn.Conv1d(64, 128, kernel_size=16), nn.ReLU())
+        self.conv1d3 = nn.Sequential(nn.Conv1d(128, 32, kernel_size=8), nn.ReLU())
+        self.conv1d4 = nn.Sequential(nn.Conv1d(32, 32, kernel_size=8), nn.ReLU())
+        self.conv1d5 = nn.Sequential(nn.Conv1d(32, 16, kernel_size=4), nn.ReLU())
+        self.mlp = MLP((self.mlp_input,), dims=self.mlp_dims)
+
+    def forward(self, x):
+        output = self.lambda_layer_1(x)
+        output = self.unsqueeze_layer1(output)
+        scale = self.lambda_layer_2(x)
+        scale = self.unsqueeze_layer2(scale)
+        output = self.conv2d1(output)
+        output = self.conv2d2(output)
+        output = torch.squeeze(output, dim=-1)
+        output = self.conv1d1(output)
+        output = self.maxpooling(output)
+        output = self.conv1d2(output)
+        output = self.maxpooling(output)
+        output = self.conv1d3(output)
+        output = self.maxpooling(output)
+        output = self.conv1d4(output)
+        output = self.conv1d5(output)
+        output = torch.flatten(output, start_dim=1)
+        output = torch.cat((output, scale), dim=1)
+        output = self.mlp(output)
+        return output
+
+
+class PositionEmbeddingVs30(nn.Module):
+    def __init__(self, wavelengths=((5, 30), (110, 123), (0.01, 5000), (100, 1600)),
+                 emb_dim=500):
+        super(PositionEmbeddingVs30, self).__init__()
+        self.wavelengths = wavelengths
+        self.emb_dim = emb_dim
+
+        min_lat, max_lat = wavelengths[0]
+        min_lon, max_lon = wavelengths[1]
+        min_depth, max_depth = wavelengths[2]
+        min_vs30, max_vs30 = wavelengths[3]
+
+        assert emb_dim % 10 == 0
+        lat_dim = emb_dim // 5
+        lon_dim = emb_dim // 5
+        depth_dim = emb_dim // 10
+        vs30_dim = emb_dim // 10
+
+        self.lat_coeff = 2 * np.pi * 1.0 / min_lat * (
+                    (min_lat / max_lat) ** (np.arange(lat_dim) / lat_dim))
+        self.lon_coeff = 2 * np.pi * 1.0 / min_lon * (
+                    (min_lon / max_lon) ** (np.arange(lon_dim) / lon_dim))
+        self.depth_coeff = 2 * np.pi * 1.0 / min_depth * (
+                    (min_depth / max_depth) ** (np.arange(depth_dim) / depth_dim))
+        self.vs30_coeff = 2 * np.pi * 1.0 / min_vs30 * (
+                    (min_vs30 / max_vs30) ** (np.arange(vs30_dim) / vs30_dim))
+
+        lat_sin_mask = np.arange(emb_dim) % 5 == 0
+        lat_cos_mask = np.arange(emb_dim) % 5 == 1
+        lon_sin_mask = np.arange(emb_dim) % 5 == 2
+        lon_cos_mask = np.arange(emb_dim) % 5 == 3
+        depth_sin_mask = np.arange(emb_dim) % 10 == 4
+        depth_cos_mask = np.arange(emb_dim) % 10 == 9
+        vs30_sin_mask = np.arange(emb_dim) % 10 == 5
+        vs30_cos_mask = np.arange(emb_dim) % 10 == 8
+
+        self.mask = np.zeros(emb_dim)
+        self.mask[lat_sin_mask] = np.arange(lat_dim)
+        self.mask[lat_cos_mask] = lat_dim + np.arange(lat_dim)
+        self.mask[lon_sin_mask] = 2 * lat_dim + np.arange(lon_dim)
+        self.mask[lon_cos_mask] = 2 * lat_dim + lon_dim + np.arange(lon_dim)
+        self.mask[depth_sin_mask] = 2 * lat_dim + 2 * lon_dim + np.arange(depth_dim)
+        self.mask[depth_cos_mask] = 2 * lat_dim + 2 * lon_dim + depth_dim + np.arange(
+            depth_dim)
+        self.mask[
+            vs30_sin_mask] = 2 * lat_dim + 2 * lon_dim + 2 * depth_dim + np.arange(
+            vs30_dim)
+        self.mask[
+            vs30_cos_mask] = 2 * lat_dim + 2 * lon_dim + 2 * depth_dim + vs30_dim + np.arange(
+            vs30_dim)
+        self.mask = self.mask.astype("int32")
+
+    def forward(self, x):
+        lat_base = x[:, :, 0:1].to(device) * torch.Tensor(self.lat_coeff).to(device)
+        lon_base = x[:, :, 1:2].to(device) * torch.Tensor(self.lon_coeff).to(device)
+        depth_base = x[:, :, 2:3].to(device) * torch.Tensor(self.depth_coeff).to(device)
+        vs30_base = x[:, :, 3:4] * torch.Tensor(self.vs30_coeff).to(device)
+
+        output = torch.cat([
+            torch.sin(lat_base), torch.cos(lat_base),
+            torch.sin(lon_base), torch.cos(lon_base),
+            torch.sin(depth_base), torch.cos(depth_base),
+            torch.sin(vs30_base), torch.cos(vs30_base),
+        ], dim=-1)
+
+        maskk = torch.from_numpy(np.array(self.mask)).long()
+        index = (maskk.unsqueeze(0).unsqueeze(0)).expand(x.shape[0], 1,
+                                                         self.emb_dim).to(device)
+        output = torch.gather(output, -1, index).to(device)
+        return output
+
+
+class TransformerEncoder(nn.Module):
+    def __init__(self, d_model=150, nhead=10, batch_first=True, activation="gelu",
+                 dropout=0.0, dim_feedforward=1000):
+        super(TransformerEncoder, self).__init__()
+        self.encoder_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead, batch_first=batch_first,
+            activation=activation, dropout=dropout, dim_feedforward=dim_feedforward
+        ).to(device)
+        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, 6).to(
+            device)
+
+    def forward(self, x, src_key_padding_mask=None):
+        return self.transformer_encoder(x, src_key_padding_mask=src_key_padding_mask)
+
+
+class MDN(nn.Module):
+    def __init__(self, input_shape=(150,), n_hidden=20, n_gaussians=5):
+        super(MDN, self).__init__()
+        self.z_h = nn.Sequential(nn.Linear(input_shape[0], n_hidden), nn.Tanh())
+        self.z_weight = nn.Linear(n_hidden, n_gaussians)
+        self.z_sigma = nn.Linear(n_hidden, n_gaussians)
+        self.z_mu = nn.Linear(n_hidden, n_gaussians)
+
+    def forward(self, x):
+        z_h = self.z_h(x)
+        weight = nn.functional.softmax(self.z_weight(z_h), -1)
+        sigma = torch.exp(self.z_sigma(z_h))
+        mu = self.z_mu(z_h)
+        return weight, sigma, mu
+
+
+class FullModel(nn.Module):
+    def __init__(self, model_cnn, model_position, model_transformer, model_mlp,
+                 model_mdn,
+                 max_station=25, pga_targets=15, emb_dim=150, data_length=6000):
+        super(FullModel, self).__init__()
+        self.data_length = data_length
+        self.model_CNN = model_cnn
+        self.model_Position = model_position
+        self.model_Transformer = model_transformer
+        self.model_mlp = model_mlp
+        self.model_MDN = model_mdn
+        self.max_station = max_station
+        self.pga_targets = pga_targets
+        self.emb_dim = emb_dim
+
+    def forward(self, data):
+        cnn_output = self.model_CNN(
+            torch.DoubleTensor(
+                data["waveform"].reshape(-1, self.data_length, 3)).float().to(device)
+        )
+        cnn_output_reshape = torch.reshape(cnn_output,
+                                           (-1, self.max_station, self.emb_dim))
+
+        emb_output = self.model_Position(
+            torch.DoubleTensor(
+                data["station"].reshape(-1, 1, data["station"].shape[2])).float().to(
+                device)
+        )
+        emb_output = emb_output.reshape(-1, self.max_station, self.emb_dim)
+
+        station_pad_mask = data["station"] == 0
+        station_pad_mask = torch.all(station_pad_mask, 2)
+
+        pga_pos_emb_output = self.model_Position(
+            torch.DoubleTensor(
+                data["target"].reshape(-1, 1, data["target"].shape[2])).float().to(
+                device)
+        )
+        pga_pos_emb_output = pga_pos_emb_output.reshape(-1, self.pga_targets,
+                                                        self.emb_dim)
+
+        target_pad_mask = torch.ones_like(data["target"], dtype=torch.bool)
+        target_pad_mask = torch.all(target_pad_mask, 2)
+        pad_mask = torch.cat((station_pad_mask, target_pad_mask), dim=1).to(device)
+
+        add_pe_cnn_output = torch.add(cnn_output_reshape, emb_output)
+        transformer_input = torch.cat((add_pe_cnn_output, pga_pos_emb_output), dim=1)
+        transformer_output = self.model_Transformer(transformer_input, pad_mask)
+
+        mlp_input = transformer_output[:, -self.pga_targets:, :].to(device)
+        mlp_output = self.model_mlp(mlp_input)
+        weight, sigma, mu = self.model_MDN(mlp_output)
+
+        return weight, sigma, mu
+
+
+def get_full_model(model_path):
+    emb_dim = 150
+    mlp_dims = (150, 100, 50, 30, 10)
+    cnn_model = CNN(mlp_input=5665).to(device)
+    pos_emb_model = PositionEmbeddingVs30(emb_dim=emb_dim).to(device)
+    transformer_model = TransformerEncoder()
+    mlp_model = MLP(input_shape=(emb_dim,), dims=mlp_dims).to(device)
+    mdn_model = MDN(input_shape=(mlp_dims[-1],)).to(device)
+    full_model = FullModel(
+        cnn_model, pos_emb_model, transformer_model, mlp_model, mdn_model,
+        pga_targets=25, data_length=3000
+    ).to(device)
+    full_model.load_state_dict(
+        torch.load(model_path, weights_only=True, map_location=device))
+    return full_model
+
+
+# 載入模型
+model_path = hf_hub_download(
+    repo_id="SeisBlue/TTSAM",
+    filename="ttsam_trained_model_11.pt"
+)
+model = get_full_model(model_path)
+
+
+# ============ 輔助函數 ============
+
+def lowpass(data, freq=10, df=100, corners=4):
+    fe = 0.5 * df
+    f = freq / fe
+    if f > 1:
+        f = 1.0
+    z, p, k = iirfilter(corners, f, btype="lowpass", ftype="butter", output="zpk")
+    sos = zpk2sos(z, p, k)
+    return sosfilt(sos, data)
+
+
+def signal_processing(waveform):
+    data = detrend(waveform, type="constant")
+    data = lowpass(data, freq=10)
+    return data
+
+
+def get_vs30(lat, lon):
+    distance, i = tree.query([float(lat), float(lon)])
+    vs30 = vs30_table.iloc[i]["Vs30"]
+    return float(vs30)
+
+
+def get_station_position(station):
+    latitude, longitude, elevation = site_info.loc[
+        (site_info["Station"] == station), ["Latitude", "Longitude", "Elevation"]
+    ].values[0]
+    return latitude, longitude, elevation
+
+
+def calculate_intensity(pga, label=False):
+    intensity_label = ["0", "1", "2", "3", "4", "5-", "5+", "6-", "6+", "7"]
+    pga_level = np.log10([1e-5, 0.008, 0.025, 0.080, 0.250, 0.80, 1.4, 2.5, 4.4, 8.0])
+
+    pga_intensity = np.searchsorted(pga_level, pga) - 1
+    intensity = pga_intensity
+
+    if label:
+        return intensity_label[intensity]
+    else:
+        return intensity
+
+
+# ============ Gradio 介面函數 ============
+
+def load_waveform(event_name):
+    file_path = EARTHQUAKE_EVENTS[event_name]
+    st = read(file_path)
+    tr = st[0]
+    times = tr.times()
+    data = tr.data
+    return times, data, tr.stats.sampling_rate
+
+
+def plot_waveform(times, data, start_time, end_time, sampling_rate):
+    fig, ax = plt.subplots(figsize=(12, 3))
+    ax.plot(times, data, 'gray', linewidth=0.5, alpha=0.6)
+
+    mask = (times >= start_time) & (times <= end_time)
+    ax.plot(times[mask], data[mask], 'blue', linewidth=1)
+
+    ax.axvline(start_time, color='red', linestyle='--', linewidth=1)
+    ax.axvline(end_time, color='red', linestyle='--', linewidth=1)
+
+    ax.set_xlabel('Time (s)')
+    ax.set_ylabel('Amplitude')
+    ax.set_title('Seismic Waveform')
+    ax.grid(True, alpha=0.3)
+
+    return fig
+
+
+def plot_intensity_map(pga_list, target_names):
+    fig, ax = plt.subplots(figsize=(6, 8))
+
+    # 繪製台灣地圖底圖
+    taiwan_lon = [120, 122]
+    taiwan_lat = [22, 25]
+
+    # 根據 target_names 取得座標
+    lats, lons, intensities = [], [], []
+    for i, target_name in enumerate(target_names):
+        target = next((t for t in target_dict if t["station"] == target_name), None)
+        if target:
+            lats.append(target["latitude"])
+            lons.append(target["longitude"])
+            intensities.append(calculate_intensity(pga_list[i]))
+
+    # 繪製散點圖
+    scatter = ax.scatter(lons, lats, c=intensities, cmap='YlOrRd', s=100,
+                         vmin=0, vmax=7, edgecolors='black', linewidth=0.5)
+
+    ax.set_xlabel('Longitude')
+    ax.set_ylabel('Latitude')
+    ax.set_title('Predicted Intensity Distribution')
+    ax.set_xlim(taiwan_lon)
+    ax.set_ylim(taiwan_lat)
+
+    cbar = plt.colorbar(scatter, ax=ax)
+    cbar.set_label('Intensity')
+
+    return fig
+
+
+def predict_intensity(event_name, start_time, end_time, lon, lat):
+    # 1. 載入波形
+    times, data, sampling_rate = load_waveform(event_name)
+
+    # 2. 切片波形
+    start_idx = int(start_time * sampling_rate)
+    end_idx = int(end_time * sampling_rate)
+    waveform_slice = data[start_idx:end_idx]
+
+    # 3. 訊號處理
+    waveform_processed = signal_processing(waveform_slice)
+
+    # 4. 準備模型輸入
+    # 假設單測站三軸資料（這裡簡化為重複使用Z軸）
+    waveform_3c = np.array(
+        [[waveform_processed, waveform_processed, waveform_processed]])
+    waveform_3c = waveform_3c.transpose(0, 2, 1)  # (1, 3000, 3)
+
+    # 準備測站資訊
+    vs30 = get_vs30(lat, lon)
+    station_info_input = np.array([[lat, lon, 100, vs30]])  # elevation 假設 100m
+
+    # 準備目標測站資訊
+    target_list = []
+    target_names = []
+    for target in target_dict[:25]:  # 限制25個目標
+        target_list.append([target["latitude"], target["longitude"],
+                            target["elevation"],
+                            get_vs30(target["latitude"], target["longitude"])])
+        target_names.append(target["station"])
+
+    # 組合成 tensor
+    tensor_data = {
+        "waveform": torch.tensor(waveform_3c).unsqueeze(0).double(),
+        "station": torch.tensor(station_info_input).unsqueeze(0).double(),
+        "target": torch.tensor(target_list).unsqueeze(0).double(),
+    }
+
+    # 5. 執行預測
+    with torch.no_grad():
+        weight, sigma, mu = model(tensor_data)
+        pga_list = torch.sum(weight * mu,
+                             dim=2).cpu().detach().numpy().flatten().tolist()
+
+    # 6. 繪製結果
+    waveform_plot = plot_waveform(times, data, start_time, end_time, sampling_rate)
+    intensity_plot = plot_intensity_map(pga_list, target_names)
+
+    # 統計資訊
+    max_intensity = max([calculate_intensity(pga, label=True) for pga in pga_list])
+    stats = f"選取時間範圍: {start_time:.1f} - {end_time:.1f} 秒\n"
+    stats += f"測站位置: ({lon:.4f}, {lat:.4f})\n"
+    stats += f"預測最大震度: {max_intensity}"
+
+    return waveform_plot, intensity_plot, stats
+
+
+# ============ Gradio 介面 ============
+
+with gr.Blocks(title="TTSAM 震度預測系統") as demo:
+    gr.Markdown("# 🌏 TTSAM 震度預測系統")
+
+    with gr.Row():
+        # 左側：輸入控制區
+        with gr.Column(scale=1):
+            gr.Markdown("## 輸入設定")
+            event_dropdown = gr.Dropdown(
+                choices=list(EARTHQUAKE_EVENTS.keys()),
+                value=list(EARTHQUAKE_EVENTS.keys())[0],
+                label="選擇地震事件"
+            )
+
+            with gr.Row():
+                start_slider = gr.Slider(0, 300, value=0, step=1, label="起始時間 (秒)")
+                end_slider = gr.Slider(0, 300, value=30, step=1, label="結束時間 (秒)")
+
+            gr.Markdown("### 測站位置")
+            with gr.Row():
+                lon_input = gr.Number(value=121.5, label="經度")
+                lat_input = gr.Number(value=24.0, label="緯度")
+
+            predict_btn = gr.Button("🔮 執行預測", variant="primary")
+
+        # 右側：震度分布圖
+        with gr.Column(scale=1):
+            gr.Markdown("## 預測震度分布")
+            intensity_plot = gr.Plot(label="震度分布圖")
+            stats_output = gr.Textbox(label="預測統計", lines=3)
+
+    # 下方：波形圖
+    with gr.Row():
+        gr.Markdown("## 輸入波形")
+    with gr.Row():
+        waveform_plot = gr.Plot(label="地震波形")
+
+    # 綁定事件
+    predict_btn.click(
+        fn=predict_intensity,
+        inputs=[event_dropdown, start_slider, end_slider, lon_input, lat_input],
+        outputs=[waveform_plot, intensity_plot, stats_output]
+    )
+
+demo.launch()

requirements.txt

@@ -0,0 +1,13 @@
+gradio
+transformers
+datasets
+torch
+obspy
+numpy
+matplotlib
+xarray
+netCDF4
+scipy
+pandas
+loguru
+huggingface_hub

station/eew_target.csv

@@ -0,0 +1,48 @@
+network,county,station,station_zh,longitude,latitude,elevation
+CWB_SMT,臺北市,TAP,臺北地震站,121.514,25.038,16
+TSMIP,新北市,A024,板橋地震站,121.475,25.019,14
+CWASN,新北市,NTS,淡水地震站,121.449,25.164,15
+CWASN,新北市,TIPB,雙溪地震站,121.826,24.972,399
+CWASN,基隆市,NOU,基隆地震站,121.773,25.149,16
+CWB_SMT,桃園市,NTY,桃園地震站,121.298,25.000,93
+CWASN,桃園市,NCU,中壢地震站,121.187,24.967,131
+TSMIP,桃園市,B011,大溪地震站,121.286,24.884,117
+CWASN,新竹市,HSN1,新竹地震站,121.018,24.779,91
+CWASN,新竹縣,HSN,竹北地震站,121.014,24.828,31
+CWASN,新竹縣,NJD,竹東地震站,121.088,24.736,131
+TSMIP,苗栗縣,B131,苗栗地震站,120.826,24.565,50
+CWB_SMT,苗栗縣,TWQ1,鯉魚潭地震站,120.781,24.346,286
+TSMIP,苗栗縣,B045,(沒有泰安)獅潭地震站,120.9206,24.5399,201
+CWASN,臺中市,TCU,臺中地震站,120.684,24.146,89
+CWASN,臺中市,WDJ,大甲地震站,120.640,24.348,99
+CWA,臺中市,WHP,烏石坑地震站,120.946,24.278,934
+CWB_SMT,南投縣,WNT1,南投地震站,120.680,23.907,118
+CWASN,南投縣,WPL,埔里地震站,120.957,24.012,465
+CWASN,南投縣,WHY,信義地震站,120.853,23.696,495
+CWASN,彰化縣,WCHH,彰化地震站,120.558,24.079,25
+CWASN,彰化縣,WYL,員林地震站,120.580,23.960,33
+CWASN,雲林縣,WDL,斗六地震站,120.539,23.715,52
+CWASN,雲林縣,WSL,水林地震站,120.228,23.523,3
+CWASN,嘉義市,CHY1,嘉義地震站,120.433,23.496,31
+TSMIP,嘉義縣,C095,太保地震站,23.46,120.29,10
+CWASN,嘉義縣,WCKO,番路地震站,120.605,23.439,233
+CWASN,臺南市,TAI,臺南地震站,120.205,22.993,19
+TSMIP,臺南市,C015,白河地震站,120.414,23.353,39
+CWB_SMT,臺南市,CHN1,楠西地震站,120.529,23.185,216
+CWASN,高雄市,KAU,前鎮地震站,22.5662,120.3157,1
+CWASN,高雄市,SCS,旗山地震站,120.494,22.885,70
+CWASN,屏東縣,SPT,屏東地震站,120.496,22.677,29
+CWASN,屏東縣,HEN,恆春地震站,120.746,22.004,26
+CWASN,屏東縣,SSD,三地門地震站,120.640,22.744,148
+CWASN,宜蘭縣,ILA,宜蘭地震站,121.756,24.764,11
+CWB_SMT,宜蘭縣,TWC,蘇澳地震站,121.860,24.608,33
+CWB_SMT,宜蘭縣,ENT,牛鬥地震站,121.574,24.638,252
+CWASN,花蓮縣,HWA,花蓮地震站,121.613,23.975,18
+CWASN,花蓮縣,EGFH,光復地震站,121.427,23.669,126
+CWASN,花蓮縣,EYUL,玉里地震站,121.319,23.347,138
+CWASN,臺東縣,TTN,臺東地震站,121.155,22.752,12
+CWASN,臺東縣,ECS,池上地震站,121.219,23.095,286
+CWASN,臺東縣,TAWH,大武地震站,120.888,22.340,24
+CWASN,澎湖縣,PNG,馬公地震站,119.564,23.565,10
+CWASN,金門縣,KNM,金門地震站,118.289,24.407,31
+CWASN,連江縣,MSU,馬祖地震站,119.923,26.169,85