做网络优化的公司排名_慈溪网页设计_运营商大数据精准营销_重庆seo整站优化

import osos.environ["KERAS_BACKEND"] = "tensorflow"import pandas as pd
import numpy as np
import typing
import matplotlib.pyplot as pltimport tensorflow as tf
import keras
from keras import layers
from keras import ops

url = "https://github.com/VeritasYin/STGCN_IJCAI-18/raw/master/dataset/PeMSD7_Full.zip"
data_dir = keras.utils.get_file(origin=url, extract=True, archive_format="zip")
data_dir = data_dir.rstrip("PeMSD7_Full.zip")route_distances = pd.read_csv(os.path.join(data_dir, "PeMSD7_W_228.csv"), header=None
).to_numpy()
speeds_array = pd.read_csv(os.path.join(data_dir, "PeMSD7_V_228.csv"), header=None
).to_numpy()print(f"route_distances shape={route_distances.shape}")
print(f"speeds_array shape={speeds_array.shape}")

sample_routes = [0,1,4,7,8,11,15,108,109,114,115,118,120,123,124,126,127,129,130,132,133,136,139,144,147,216,
]
route_distances = route_distances[np.ix_(sample_routes, sample_routes)]
speeds_array = speeds_array[:, sample_routes]print(f"route_distances shape={route_distances.shape}")
print(f"speeds_array shape={speeds_array.shape}")

plt.figure(figsize=(18, 6))
plt.plot(speeds_array[:, [0, -1]])
plt.legend(["route_0", "route_25"])

plt.figure(figsize=(8, 8))
plt.matshow(np.corrcoef(speeds_array.T), 0)
plt.xlabel("road number")
plt.ylabel("road number")

train_size, val_size = 0.5, 0.2def preprocess(data_array: np.ndarray, train_size: float, val_size: float):"""Splits data into train/val/test sets and normalizes the data.    Args:
        data_array: ndarray of shape `(num_time_steps, num_routes)`
        train_size: A float value between 0.0 and 1.0 that represent the proportion of the dataset
            to include in the train split.
        val_size: A float value between 0.0 and 1.0 that represent the proportion of the dataset
            to include in the validation split.    Returns:
        `train_array`, `val_array`, `test_array`
    """num_time_steps = data_array.shape[0]num_train, num_val = (int(num_time_steps * train_size),int(num_time_steps * val_size),)train_array = data_array[:num_train]mean, std = train_array.mean(axis=0), train_array.std(axis=0)train_array = (train_array - mean) / stdval_array = (data_array[num_train : (num_train + num_val)] - mean) / stdtest_array = (data_array[(num_train + num_val) :] - mean) / stdreturn train_array, val_array, test_arraytrain_array, val_array, test_array = preprocess(speeds_array, train_size, val_size)print(f"train set size: {train_array.shape}")
print(f"validation set size: {val_array.shape}")
print(f"test set size: {test_array.shape}")

batch_size = 64
input_sequence_length = 12
forecast_horizon = 3
multi_horizon = Falsedef create_tf_dataset(data_array: np.ndarray,input_sequence_length: int,forecast_horizon: int,batch_size: int = 128,shuffle=True,multi_horizon=True,
):"""Creates tensorflow dataset from numpy array.    This function creates a dataset where each element is a tuple `(inputs, targets)`.
    `inputs` is a Tensor
    of shape `(batch_size, input_sequence_length, num_routes, 1)` containing
    the `input_sequence_length` past values of the timeseries for each node.
    `targets` is a Tensor of shape `(batch_size, forecast_horizon, num_routes)`
    containing the `forecast_horizon`
    future values of the timeseries for each node.    Args:
        data_array: np.ndarray with shape `(num_time_steps, num_routes)`
        input_sequence_length: Length of the input sequence (in number of timesteps).
        forecast_horizon: If `multi_horizon=True`, the target will be the values of the timeseries for 1 to
            `forecast_horizon` timesteps ahead. If `multi_horizon=False`, the target will be the value of the
            timeseries `forecast_horizon` steps ahead (only one value).
        batch_size: Number of timeseries samples in each batch.
        shuffle: Whether to shuffle output samples, or instead draw them in chronological order.
        multi_horizon: See `forecast_horizon`.    Returns:
        A tf.data.Dataset instance.
    """inputs = keras.utils.timeseries_dataset_from_array(np.expand_dims(data_array[:-forecast_horizon], axis=-1),None,sequence_length=input_sequence_length,shuffle=False,batch_size=batch_size,)target_offset = (input_sequence_lengthif multi_horizonelse input_sequence_length + forecast_horizon - 1)target_seq_length = forecast_horizon if multi_horizon else 1targets = keras.utils.timeseries_dataset_from_array(data_array[target_offset:],None,sequence_length=target_seq_length,shuffle=False,batch_size=batch_size,)dataset = tf.data.Dataset.zip((inputs, targets))if shuffle:dataset = dataset.shuffle(100)return dataset.prefetch(16).cache()train_dataset, val_dataset = (create_tf_dataset(data_array, input_sequence_length, forecast_horizon, batch_size)for data_array in [train_array, val_array]
)test_dataset = create_tf_dataset(test_array,input_sequence_length,forecast_horizon,batch_size=test_array.shape[0],shuffle=False,multi_horizon=multi_horizon,
)

def compute_adjacency_matrix(route_distances: np.ndarray, sigma2: float, epsilon: float
):"""Computes the adjacency matrix from distances matrix.    It uses the formula in https://github.com/VeritasYin/STGCN_IJCAI-18#data-preprocessing to
    compute an adjacency matrix from the distance matrix.
    The implementation follows that paper.    Args:
        route_distances: np.ndarray of shape `(num_routes, num_routes)`. Entry `i,j` of this array is the
            distance between roads `i,j`.
        sigma2: Determines the width of the Gaussian kernel applied to the square distances matrix.
        epsilon: A threshold specifying if there is an edge between two nodes. Specifically, `A[i,j]=1`
            if `np.exp(-w2[i,j] / sigma2) >= epsilon` and `A[i,j]=0` otherwise, where `A` is the adjacency
            matrix and `w2=route_distances * route_distances`    Returns:
        A boolean graph adjacency matrix.
    """num_routes = route_distances.shape[0]route_distances = route_distances / 10000.0w2, w_mask = (route_distances * route_distances,np.ones([num_routes, num_routes]) - np.identity(num_routes),)return (np.exp(-w2 / sigma2) >= epsilon) * w_mask

class GraphInfo:def __init__(self, edges: typing.Tuple[list, list], num_nodes: int):self.edges = edgesself.num_nodes = num_nodessigma2 = 0.1
epsilon = 0.5
adjacency_matrix = compute_adjacency_matrix(route_distances, sigma2, epsilon)
node_indices, neighbor_indices = np.where(adjacency_matrix == 1)
graph = GraphInfo(edges=(node_indices.tolist(), neighbor_indices.tolist()),num_nodes=adjacency_matrix.shape[0],
)
print(f"number of nodes: {graph.num_nodes}, number of edges: {len(graph.edges[0])}")

class GraphConv(layers.Layer):def __init__(self,in_feat,out_feat,graph_info: GraphInfo,aggregation_type="mean",combination_type="concat",activation: typing.Optional[str] = None,**kwargs,):super().__init__(**kwargs)self.in_feat = in_featself.out_feat = out_featself.graph_info = graph_infoself.aggregation_type = aggregation_typeself.combination_type = combination_typeself.weight = self.add_weight(initializer=keras.initializers.GlorotUniform(),shape=(in_feat, out_feat),dtype="float32",trainable=True,)self.activation = layers.Activation(activation)def aggregate(self, neighbour_representations):aggregation_func = {"sum": tf.math.unsorted_segment_sum,"mean": tf.math.unsorted_segment_mean,"max": tf.math.unsorted_segment_max,}.get(self.aggregation_type)if aggregation_func:return aggregation_func(neighbour_representations,self.graph_info.edges[0],num_segments=self.graph_info.num_nodes,)raise ValueError(f"Invalid aggregation type: {self.aggregation_type}")def compute_nodes_representation(self, features):"""Computes each node's representation.        The nodes' representations are obtained by multiplying the features tensor with
        `self.weight`. Note that
        `self.weight` has shape `(in_feat, out_feat)`.        Args:
            features: Tensor of shape `(num_nodes, batch_size, input_seq_len, in_feat)`        Returns:
            A tensor of shape `(num_nodes, batch_size, input_seq_len, out_feat)`
        """return ops.matmul(features, self.weight)def compute_aggregated_messages(self, features):neighbour_representations = tf.gather(features, self.graph_info.edges[1])aggregated_messages = self.aggregate(neighbour_representations)return ops.matmul(aggregated_messages, self.weight)def update(self, nodes_representation, aggregated_messages):if self.combination_type == "concat":h = ops.concatenate([nodes_representation, aggregated_messages], axis=-1)elif self.combination_type == "add":h = nodes_representation + aggregated_messageselse:raise ValueError(f"Invalid combination type: {self.combination_type}.")return self.activation(h)def call(self, features):"""Forward pass.        Args:
            features: tensor of shape `(num_nodes, batch_size, input_seq_len, in_feat)`        Returns:
            A tensor of shape `(num_nodes, batch_size, input_seq_len, out_feat)`
        """nodes_representation = self.compute_nodes_representation(features)aggregated_messages = self.compute_aggregated_messages(features)return self.update(nodes_representation, aggregated_messages)

class LSTMGC(layers.Layer):"""Layer comprising a convolution layer followed by LSTM and dense layers."""def __init__(self,in_feat,out_feat,lstm_units: int,input_seq_len: int,output_seq_len: int,graph_info: GraphInfo,graph_conv_params: typing.Optional[dict] = None,**kwargs,):super().__init__(**kwargs)# graph conv layerif graph_conv_params is None:graph_conv_params = {"aggregation_type": "mean","combination_type": "concat","activation": None,}self.graph_conv = GraphConv(in_feat, out_feat, graph_info, **graph_conv_params)self.lstm = layers.LSTM(lstm_units, activation="relu")self.dense = layers.Dense(output_seq_len)self.input_seq_len, self.output_seq_len = input_seq_len, output_seq_lendef call(self, inputs):"""Forward pass.        Args:
            inputs: tensor of shape `(batch_size, input_seq_len, num_nodes, in_feat)`        Returns:
            A tensor of shape `(batch_size, output_seq_len, num_nodes)`.
        """# convert shape to  (num_nodes, batch_size, input_seq_len, in_feat)inputs = ops.transpose(inputs, [2, 0, 1, 3])gcn_out = self.graph_conv(inputs)  # gcn_out has shape: (num_nodes, batch_size, input_seq_len, out_feat)shape = ops.shape(gcn_out)num_nodes, batch_size, input_seq_len, out_feat = (shape[0],shape[1],shape[2],shape[3],)# LSTM takes only 3D tensors as inputgcn_out = ops.reshape(gcn_out, (batch_size * num_nodes, input_seq_len, out_feat))lstm_out = self.lstm(gcn_out)  # lstm_out has shape: (batch_size * num_nodes, lstm_units)dense_output = self.dense(lstm_out)  # dense_output has shape: (batch_size * num_nodes, output_seq_len)output = ops.reshape(dense_output, (num_nodes, batch_size, self.output_seq_len))return ops.transpose(output, [1, 2, 0])  # returns Tensor of shape (batch_size, output_seq_len, num_nodes)

in_feat = 1
batch_size = 64
epochs = 20
input_sequence_length = 12
forecast_horizon = 3
multi_horizon = False
out_feat = 10
lstm_units = 64
graph_conv_params = {"aggregation_type": "mean","combination_type": "concat","activation": None,
}st_gcn = LSTMGC(in_feat,out_feat,lstm_units,input_sequence_length,forecast_horizon,graph,graph_conv_params,
)
inputs = layers.Input((input_sequence_length, graph.num_nodes, in_feat))
outputs = st_gcn(inputs)model = keras.models.Model(inputs, outputs)
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=0.0002),loss=keras.losses.MeanSquaredError(),
)
model.fit(train_dataset,validation_data=val_dataset,epochs=epochs,callbacks=[keras.callbacks.EarlyStopping(patience=10)],
)

x_test, y = next(test_dataset.as_numpy_iterator())
y_pred = model.predict(x_test)
plt.figure(figsize=(18, 6))
plt.plot(y[:, 0, 0])
plt.plot(y_pred[:, 0, 0])
plt.legend(["actual", "forecast"])naive_mse, model_mse = (np.square(x_test[:, -1, :, 0] - y[:, 0, :]).mean(),np.square(y_pred[:, 0, :] - y[:, 0, :]).mean(),
)
print(f"naive MAE: {naive_mse}, model MAE: {model_mse}")