wq!New: Largest CODE

code/LargeST/to_largest.py

@@ -0,0 +1,114 @@
+import os
+
+import numpy as np
+import pandas as pd
+
+
+class StandardScaler:
+    """
+    This scaler code is borrowed from https://github.com/liuxu77/LargeST/blob/main/data/generate_data_for_training.py
+    """
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+    def transform(self, data):
+        return (data - self.mean) / self.std
+
+    def inverse_transform(self, data):
+        return (data * self.std) + self.mean
+
+
+def generate_data_and_idx(df: pd.DataFrame, x_offsets, y_offsets, add_time_of_day, add_day_of_week):
+    num_samples, num_nodes = df.shape
+    data = np.expand_dims(df.values, axis=-1)
+
+    feature_list = [data]
+    if add_time_of_day:
+        time_ind = (df.index.values - df.index.values.astype('datetime64[D]')) / np.timedelta64(1, 'D')
+        time_of_day = np.tile(time_ind, [1, num_nodes, 1]).transpose((2, 1, 0))
+        feature_list.append(time_of_day)
+    if add_day_of_week:
+        dow = df.index.dayofweek
+        dow_tiled = np.tile(dow, [1, num_nodes, 1]).transpose((2, 1, 0))
+        day_of_week = dow_tiled / 7
+        feature_list.append(day_of_week)
+
+    data = np.concatenate(feature_list, axis=-1)
+
+    min_t = abs(min(x_offsets))
+    max_t = abs(num_samples - abs(max(y_offsets)))  # Exclusive
+    print('idx min & max:', min_t, max_t)
+    idx = np.arange(min_t, max_t, 1)
+    return data, idx
+
+
+def new_and_dying_sensors(df: pd.DataFrame):
+    df = df.sort_index()
+
+    isna   = df.isna()
+    valid  = ~isna
+
+    has_before = valid.cumsum(axis=0).gt(0)
+    has_after  = valid[::-1].cumsum(axis=0)[::-1].gt(0)
+
+    leading_nan = isna & ~has_before
+    trailing_nan = isna & ~has_after
+    internal_nan = isna & has_before & has_after
+
+    newborn_cols = leading_nan.any(axis=0)
+    dying_cols   = trailing_nan.any(axis=0)
+    invalid_cols = internal_nan.any(axis=0) | isna.all(axis=0)
+
+    newborn_sensors = df.columns[newborn_cols].tolist()
+    dying_sensors   = df.columns[dying_cols].tolist()
+    invalid_sensors = df.columns[invalid_cols].tolist()
+
+    return newborn_sensors, dying_sensors, invalid_sensors
+
+
+def generate_largest_data(df: pd.DataFrame, output_folder: str, sensors: list = None, seq_len_x: int = 12, seq_len_y: int = 12,
+                          splits: dict[str, float] = None):
+
+    if splits is None:
+        splits = {'train': 0.6, 'val': 0.2}
+
+    x_offsets = np.sort(np.arange(-(seq_len_x - 1), 1, 1))
+    y_offsets = np.sort(np.arange(1, seq_len_y + 1, 1))
+
+    if sensors is not None:
+        df = df[df['sensor_id'].isin(sensors)]
+
+    df['traffic_intensity'] = df['traffic_intensity'] / 4   # data is a 15-min interval but represented as per hour
+    df_pivot = df.pivot(index='entry_date', columns='sensor_id', values='traffic_intensity')
+    print('original data shape:', df_pivot.shape)
+
+    newborn, dying, invalid = new_and_dying_sensors(df_pivot)
+    if len(invalid) > 0:
+        raise Exception("invalid sensors (with nans inside) found")
+
+    to_drop = set(newborn) | set(dying)
+    df_clean = df_pivot.drop(columns=to_drop)
+    data, idx = generate_data_and_idx(df_clean, x_offsets, y_offsets, add_time_of_day=True, add_day_of_week=True)
+    print('final data shape:', data.shape, 'idx shape:', idx.shape)
+
+    # generate splits
+    num_samples = len(idx)
+    num_train = int(num_samples * splits['train'])
+    num_val = int(num_samples * splits['val'])
+    num_test = num_samples - num_train - num_val
+    idx_train = idx[:num_train]
+    idx_val = idx[num_train:num_train + num_val]
+    idx_test = idx[num_train + num_val:]
+
+    # normalize data
+    x_train = data[:idx_val[0] - seq_len_x, :, 0]
+    scaler = StandardScaler(mean=x_train.mean(), std=x_train.std())
+    data[..., 0] = scaler.transform(data[..., 0])
+
+    # save data
+    os.makedirs(output_folder, exist_ok=True)
+    np.savez_compressed(os.path.join(output_folder, 'his.npz'), data=data, mean=scaler.mean, std=scaler.std)
+    np.save(os.path.join(output_folder, 'idx_train.npy'), idx_train)
+    np.save(os.path.join(output_folder, 'idx_val.npy'), idx_val)
+    np.save(os.path.join(output_folder, 'idx_test.npy'), idx_test)

code/README.md

@@ -0,0 +1,11 @@
+# GO-MO traffic dataset source code
+
+Here you can find code for several tasks related to the GO-MO traffic dataset:
+* Exporting the road network graph to a derived line graph, where the streets/edges are transformed into vertices and 
+juntctions/vertices are transformed into edges.
+* Exporting the road network graph or the route graph to Pytorch Geometric data format.
+* Exporting the road network graph or the route graph to a numpy adjacency matrix.
+
+In the LargeST folder you can find code to:
+* Generate data and adjacency matrix compatibles with LargeST benchmark to reproduce benchmarking experiments present in
+the GO-MO paper.

code/graph_format.py

@@ -3,8 +3,6 @@ import torch
 from torch_geometric.data import Data
 import networkx as nx
 
-from stats import print_graph_stats
-
 
 def _get_float_value(v):
     if isinstance(v, str) and "|" in v:

code/load_dataset.py

@@ -0,0 +1,14 @@
+import pandas as pd
+from datasets import load_dataset, Value
+
+from LargeST.to_largest import generate_largest_data
+
+repo_id = "double-blind-anonymous/go-mo-dataset"
+
+data = load_dataset(repo_id, data_files={'train': "traffic_data_2024.csv"}, split="train")
+# data = data.cast_column("entry_date", Value("timestamp[s]"))
+df = data.to_pandas()
+print(df.head())
+print(df.shape)
+
+generate_largest_data(df, "/mnt/raid/code/dmariaa/go-mo-dataset/code/data")