From 6e87edb2fe2269724c2aa9d22a2f6e48305066b9 Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Fri, 7 Aug 2020 11:27:50 +0100 Subject: [PATCH 1/8] GPLandscape new method --- SpatialScan/scoot_gp.py | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/SpatialScan/scoot_gp.py b/SpatialScan/scoot_gp.py index 80644d5..e307b63 100644 --- a/SpatialScan/scoot_gp.py +++ b/SpatialScan/scoot_gp.py @@ -149,7 +149,7 @@ def load_landscape(self): det_date = pd.read_csv("gp_models/det_date.csv", index_col=False) detectors = det_date["detectors"].to_numpy() dates = det_date["last_update_start"].astype("datetime64[h]").to_numpy() - end_dates = det_date["last_update_start"].astype("datetime64[h]").to_numpy() + end_dates = det_date["last_update_end"].astype("datetime64[h]").to_numpy() for i, detector in enumerate(detectors, 1): @@ -166,7 +166,7 @@ def load_landscape(self): self.scalers = scalers def count_baseline( - self, scoot_df: pd.DataFrame, detectors: list = None + self, scoot_df: pd.DataFrame, detectors: list = None, type = "forecast" ) -> pd.DataFrame: """Produces a DataFrame where the count and baseline can be compared for use in scan statistics @@ -201,13 +201,31 @@ def count_baseline( start_of_trained_data = self.model_last_update_start[ np.where(self.model_detector_id == detector) ] + end_of_trained_data = self.model_last_update_end[ + np.where(self.model_detector_id == detector) + ] - baseline_range = ( - (one_detector_df["measurement_end_utc"] - start_of_trained_data[0]) - .to_numpy() - .astype("timedelta64[h]") - ) - baseline_range = baseline_range + np.timedelta64(1, "h") + if type == "forecast" : + baseline_range = ( + (one_detector_df["measurement_end_utc"] - start_of_trained_data[0]) + .to_numpy() + .astype("timedelta64[h]") + ) + baseline_range = baseline_range + np.timedelta64(1, "h") + + print(baseline_range) + + if type == "nextweek": + start_range = (one_detector_df["measurement_end_utc"].min() - end_of_trained_data[0])/np.timedelta64(1, 'h') + start_range = start_range%168 + (end_of_trained_data[0] - start_of_trained_data[0])/np.timedelta64(1, 'h') + 1 + print(start_range) + baseline_range = np.arange(start_range, start_range + len(one_detector_df["measurement_end_utc"])) + + #baseline_range = baseline_range + 1 + + print(baseline_range) + + loc = np.where(self.model_detector_id == detector) From 632a33f88ee5b9a9bcac6442f5e86a4cb75ae4db Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Mon, 10 Aug 2020 15:11:58 +0100 Subject: [PATCH 2/8] multivariate --- SpatialScan/multi_scoot_gp.py | 71 +++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 SpatialScan/multi_scoot_gp.py diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py new file mode 100644 index 0000000..c8f7655 --- /dev/null +++ b/SpatialScan/multi_scoot_gp.py @@ -0,0 +1,71 @@ + +import tensorflow as tf +from sklearn.preprocessing import MinMaxScaler + +import pandas as pd +import numpy as np + +import gpflow + +# from gpflow.utilities import print_summary, set_trainable + +import joblib + +def multi_gp(train, forecasting, detectors=None, kern=None): + + if kern == None: + kern_pd = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_pw = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_se = gpflow.kernels.SquaredExponential() + + kern_pd.period.assign(24.0) + kern_pw.period.assign(168.0) + # kern_SE.lengthscales.assign(100) + + kern = kern_pd * kern_pw + kern_se + + if detectors == None: + detectors=train["detector_id"].unique() + + Y=[] + X=[] + for detector in detectors: + dataset=train[train["detector_id"]==detector] + X=(dataset["measurement_end_utc"]-dataset["measurement_end_utc"].min()).astype("timedelta64[h]").to_numpy().reshape(-1, 1) + Y.append(dataset["n_vehicles_in_interval"].tolist()) + Y=np.array(Y) + Y=Y.T + + + scaler = MinMaxScaler(feature_range=(-1, 1)) + y = scaler.fit_transform(Y) + + # fit our GP to X & y + model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() + + # optimise GP performance + opt.minimize( + model.training_loss, model.trainable_variables, options=dict(maxiter=10000) + ) + + prediction_start = (forecasting["measurement_end_utc"].min()-dataset["measurement_end_utc"].min())/np.timedelta64(1, 'h') + prediction_end = (forecasting["measurement_end_utc"].max()-dataset["measurement_end_utc"].min())/np.timedelta64(1, 'h') + prediction_range = np.arange(prediction_start, prediction_end + 1) + mean, var = model.predict_f(prediction_range) + mean = scaler.inverse_transform(mean) + var = scaler.inverse_transform(var) + + mean=mean.T + var=var.T + + framelist=[] + for d, detector in enumerate(sample, 0): + dataset=forecasting[forecasting["detector_id"]==detector] + dataset["baseline"]=mean[d] + dataset["prediction_variance"]=var[d] + framelist.append(dataset) + output=pd.concat(framelist) + + output=output.rename(columns={'n_vehicles_in_interval': "count"}) + return output \ No newline at end of file From f8c009cc01b1116064d497cf63d463ac509dc274 Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Tue, 11 Aug 2020 09:52:53 +0100 Subject: [PATCH 3/8] black --- SpatialScan/multi_scoot_gp.py | 63 +++++++++++++++++------------------ 1 file changed, 31 insertions(+), 32 deletions(-) diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index c8f7655..47ff8dd 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -1,19 +1,12 @@ - -import tensorflow as tf from sklearn.preprocessing import MinMaxScaler - import pandas as pd import numpy as np - import gpflow -# from gpflow.utilities import print_summary, set_trainable - -import joblib def multi_gp(train, forecasting, detectors=None, kern=None): - if kern == None: + if kern is None: kern_pd = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) kern_pw = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) kern_se = gpflow.kernels.SquaredExponential() @@ -23,20 +16,22 @@ def multi_gp(train, forecasting, detectors=None, kern=None): # kern_SE.lengthscales.assign(100) kern = kern_pd * kern_pw + kern_se - - if detectors == None: - detectors=train["detector_id"].unique() - - Y=[] - X=[] + if detectors is None: + detectors = train["detector_id"].unique() + Y = [] + X = [] for detector in detectors: - dataset=train[train["detector_id"]==detector] - X=(dataset["measurement_end_utc"]-dataset["measurement_end_utc"].min()).astype("timedelta64[h]").to_numpy().reshape(-1, 1) + dataset = train[train["detector_id"] == detector] + X = ( + (dataset["measurement_end_utc"] - dataset["measurement_end_utc"].min()) + .astype("timedelta64[h]") + .to_numpy() + .reshape(-1, 1) + ) Y.append(dataset["n_vehicles_in_interval"].tolist()) - Y=np.array(Y) - Y=Y.T + Y = np.array(Y) + Y = Y.T - scaler = MinMaxScaler(feature_range=(-1, 1)) y = scaler.fit_transform(Y) @@ -49,23 +44,27 @@ def multi_gp(train, forecasting, detectors=None, kern=None): model.training_loss, model.trainable_variables, options=dict(maxiter=10000) ) - prediction_start = (forecasting["measurement_end_utc"].min()-dataset["measurement_end_utc"].min())/np.timedelta64(1, 'h') - prediction_end = (forecasting["measurement_end_utc"].max()-dataset["measurement_end_utc"].min())/np.timedelta64(1, 'h') - prediction_range = np.arange(prediction_start, prediction_end + 1) + prediction_start = ( + forecasting["measurement_end_utc"].min() - dataset["measurement_end_utc"].min() + ) / np.timedelta64(1, "h") + prediction_end = ( + forecasting["measurement_end_utc"].max() - dataset["measurement_end_utc"].min() + ) / np.timedelta64(1, "h") + prediction_range = np.arange(prediction_start, prediction_end + 1).reshape(-1, 1) mean, var = model.predict_f(prediction_range) mean = scaler.inverse_transform(mean) var = scaler.inverse_transform(var) - mean=mean.T - var=var.T + mean = mean.T + var = var.T - framelist=[] - for d, detector in enumerate(sample, 0): - dataset=forecasting[forecasting["detector_id"]==detector] - dataset["baseline"]=mean[d] - dataset["prediction_variance"]=var[d] + framelist = [] + for d, detector in enumerate(detectors, 0): + dataset = forecasting[forecasting["detector_id"] == detector] + dataset["baseline"] = mean[d] + dataset["prediction_variance"] = var[d] framelist.append(dataset) - output=pd.concat(framelist) + output = pd.concat(framelist) - output=output.rename(columns={'n_vehicles_in_interval': "count"}) - return output \ No newline at end of file + output = output.rename(columns={"n_vehicles_in_interval": "count"}) + return output From 7a7dfde199168e29282a2735660253cae090f27b Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Tue, 11 Aug 2020 16:53:36 +0100 Subject: [PATCH 4/8] put in class --- SpatialScan/multi_scoot_gp.py | 124 +++++++++++++++++++++++++++++++++- 1 file changed, 123 insertions(+), 1 deletion(-) diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index 47ff8dd..048a2ba 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -2,9 +2,123 @@ import pandas as pd import numpy as np import gpflow +from gpflow.utilities import print_summary -def multi_gp(train, forecasting, detectors=None, kern=None): +class MultiGP: + + def __init__(self): + self.model = None + self.model_training_info = None + self.scaler = None + + def train(self, training_scoot_df, detectors=None, kern=None): + + # set up kernels + if kern is None: + kern_pd = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_pw = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_se = gpflow.kernels.SquaredExponential() + + kern_pd.period.assign(24.0) + kern_pw.period.assign(168.0) + kern = kern_pd * kern_pw + kern_se + + if detectors is None: + detectors = training_scoot_df["detector_id"].unique() + + + Y = [] + X = [] + starts = [] + ends = [] + for detector in detectors: + dataset = training_scoot_df[training_scoot_df["detector_id"] == detector] + + X = ( + (dataset["measurement_end_utc"] - dataset["measurement_end_utc"].min()) + .astype("timedelta64[h]") + .to_numpy() + .reshape(-1, 1) + ) + + starts.append(dataset["measurement_end_utc"].min()) + ends.append(dataset["measurement_end_utc"].max()) + + Y.append(dataset["n_vehicles_in_interval"].tolist()) + + self.model_training_info = pd.DataFrame({"detector_id" : detectors, "training_start" : starts, "training_end" : ends}) + + Y = np.array(Y) + Y = Y.T + + scaler = MinMaxScaler(feature_range=(-1, 1)) + y = scaler.fit_transform(Y) + + # fit our GP to X & y + model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() + + print("BEFORE OPTIMISATION") + print_summary(model) + + opt.minimize( + model.training_loss, model.trainable_variables, options=dict(maxiter=10000)) + + print("AFTER OPTIMISATION") + print_summary(model) + + self.model = model + self.scaler = scaler + + def forecast(self, forecast_scoot_df, detectors: list = None): + + pd.options.mode.chained_assignment = None + + if detectors is None: + detectors = forecast_scoot_df["detector_id"].drop_duplicates().to_numpy() + + detectors_in=np.intersect1d(detectors, self.model_training_info["detector_id"].to_numpy()) + + if(detectors_in!=detectors): + print("Model not trained for: ", np.setdiff1d(detectors, detectors_in)) + print("Calculating for remaining detectors...") + detectors=detectors_in + + prediction_start = ( + forecast_scoot_df["measurement_end_utc"].min() - self.model_training_info["training_start"].min() + ) / np.timedelta64(1, "h") + prediction_end = ( + forecast_scoot_df["measurement_end_utc"].max() - self.model_training_info["training_start"].min() + ) / np.timedelta64(1, "h") + + prediction_range = np.arange(prediction_start, prediction_end + 1).reshape(-1, 1) + + mean, var = self.model.predict_f(prediction_range) + mean = self.scaler.inverse_transform(mean) + var = self.scaler.inverse_transform(var) + + mean = mean.T + var = var.T + + framelist = [] + for d, detector in enumerate(detectors, 0): + dataset = forecast_scoot_df[forecast_scoot_df["detector_id"] == detector] + dataset["baseline"] = mean[d] + dataset["prediction_variance"] = var[d] + dataset["upper_99"] = mean[d] + 3 * np.sqrt(var[d]) + dataset["lower_99"] = mean[d] - 3 * np.sqrt(var[d]) + framelist.append(dataset) + + output = pd.concat(framelist) + output = output.rename(columns={"n_vehicles_in_interval": "count"}) + return output + + + + + +def multi_gp1(train, forecasting, detectors=None, kern=None): if kern is None: kern_pd = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) @@ -32,6 +146,8 @@ def multi_gp(train, forecasting, detectors=None, kern=None): Y = np.array(Y) Y = Y.T + print(X.shape, Y.shape) + scaler = MinMaxScaler(feature_range=(-1, 1)) y = scaler.fit_transform(Y) @@ -39,6 +155,9 @@ def multi_gp(train, forecasting, detectors=None, kern=None): model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) opt = gpflow.optimizers.Scipy() + print("BEFORE OPTIMISATION") + print_summary(model) + # optimise GP performance opt.minimize( model.training_loss, model.trainable_variables, options=dict(maxiter=10000) @@ -66,5 +185,8 @@ def multi_gp(train, forecasting, detectors=None, kern=None): framelist.append(dataset) output = pd.concat(framelist) + print("AFTER OPTIMISATION") + print_summary(model) + output = output.rename(columns={"n_vehicles_in_interval": "count"}) return output From 5fd030c7280cf7b8cf0e065c73788e2217f95061 Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Tue, 18 Aug 2020 10:45:36 +0100 Subject: [PATCH 5/8] Multioutput, Multivariate --- SpatialScan/multi_scoot_gp.py | 126 +++++++++++++++++++++++++++++++--- SpatialScan/preprocessing.py | 5 +- 2 files changed, 119 insertions(+), 12 deletions(-) diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index 048a2ba..07abd5e 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -4,16 +4,86 @@ import gpflow from gpflow.utilities import print_summary +class MultiVariateGP: + + def __init__(self): + self.model = None + self.model_training_info = None + self.scaler = None -class MultiGP: + def create_dataset(self, scoot_df, detectors, target, days): + x=[] + for i, detector in enumerate(detectors, 0): + dataset=scoot_df[scoot_df["detector_id"]==detector] + dataset = dataset["n_vehicles_in_interval"].to_numpy() + if detector == target: + y = dataset[24*days:] + x.append(dataset[:-24*days]) + return(x, y) + + def train(self, scoot_df, detectors, target, days = 7): + x, y = self.create_dataset(scoot_df, detectors, target, days=days) + X = np.array(x).T + Y = y.reshape(-1, 1) + Y = Y.astype(float) + kern = gpflow.kernels.Linear() + model = gpflow.models.GPR(data=(X, Y), kernel=kern, mean_function=None) + + opt = gpflow.optimizers.Scipy() + + opt.minimize( + model.training_loss, + model.trainable_variables, + options=dict(maxiter=500), + ) + + self.model = model + return model + + def count_baseline(self, train_df, count_df, detectors, days=7): + frame_list=[] + for i, detector in enumerate(detectors, 1): + print("please wait: ", i, "/", len(detectors), end="\r") + model = self.train(train_df, detectors, detector,days=days) + x, y = self.create_dataset(count_df, detectors, detector, days=days) + X = np.array(x).T + mean, var = model.predict_f(X) + mean = mean.numpy().flatten() + var = var.numpy().flatten() + single_detector_df = count_df[count_df["detector_id"] == detector] + forecast_period = (single_detector_df[single_detector_df["measurement_end_utc"] >= single_detector_df["measurement_end_utc"].min() + np.timedelta64(days*24, "h")]["measurement_end_utc"]).to_numpy() + print(len(y), len(forecast_period)) + forecast_df = pd.DataFrame( + { + "count": y, + "baseline": mean, + "prediction_variance": var, + "baseline_upper":mean + + 3 * np.sqrt(var), + "baseline_lower": mean + - 3 * np.sqrt(var), + "detector_id": detector, + "lon": single_detector_df[single_detector_df["detector_id"] == detector]["lon"].iloc[0], + "lat": single_detector_df[single_detector_df["detector_id"] == detector]["lat"].iloc[0], + "measurement_end_utc": forecast_period, + } + ) + frame_list.append(forecast_df) + + del model + + return pd.concat(frame_list) + + +class MultiOutputGP: def __init__(self): self.model = None self.model_training_info = None self.scaler = None - def train(self, training_scoot_df, detectors=None, kern=None): - + def train(self, training_scoot_df, detectors=None, kern=None, method="GPR", num_induce=50): + """method""" # set up kernels if kern is None: kern_pd = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) @@ -56,14 +126,47 @@ def train(self, training_scoot_df, detectors=None, kern=None): y = scaler.fit_transform(Y) # fit our GP to X & y - model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) - opt = gpflow.optimizers.Scipy() - - print("BEFORE OPTIMISATION") - print_summary(model) - - opt.minimize( - model.training_loss, model.trainable_variables, options=dict(maxiter=10000)) + if method == "GPR": + model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() + print("BEFORE OPTIMISATION") + print_summary(model) + + opt.minimize( + model.training_loss, model.trainable_variables, options=dict(maxiter=10000)) + + if method == "sharedkern": + kern = gpflow.kernels.SharedIndependent(kern, output_dim=len(detectors)) + Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] + # initialization of inducing input locations (M random points from the training inputs) + Z = Zinit.copy() + iv = gpflow.inducing_variables.SharedIndependentInducingVariables( + gpflow.inducing_variables.InducingPoints(Z)) + # create SVGP model as usual and optimize + model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=len(detectors)) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss_closure((X, y)), + variables=model.trainable_variables, + method="l-bfgs-b", + options={"disp": True, "maxiter": 10000},) + + if method == "seperatekern": + kern_list = [kern for _ in range(len(detectors))] + kern = gpflow.kernels.SeparateIndependent(kern_list) + Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] + # initialization of inducing input locations (M random points from the training inputs) + Z = Zinit.copy() + iv = gpflow.inducing_variables.SharedIndependentInducingVariables( + gpflow.inducing_variables.InducingPoints(Z)) + # create SVGP model as usual and optimize + model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=len(detectors)) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss_closure((X, y)), + variables=model.trainable_variables, + method="l-bfgs-b", + options={"disp": True, "maxiter": 10000},) print("AFTER OPTIMISATION") print_summary(model) @@ -190,3 +293,4 @@ def multi_gp1(train, forecasting, detectors=None, kern=None): output = output.rename(columns={"n_vehicles_in_interval": "count"}) return output + diff --git a/SpatialScan/preprocessing.py b/SpatialScan/preprocessing.py index d2d31e7..991611b 100644 --- a/SpatialScan/preprocessing.py +++ b/SpatialScan/preprocessing.py @@ -451,6 +451,7 @@ def jam_preprocessor( orig_set = set(df.index.get_level_values("detector_id")) orig_length = len(orig_set) + print("Dropping detectors with more than {} anomalies...".format(max_anom)) df = df.drop(df[df["Num_Anom"] > max_anom].index) @@ -471,6 +472,8 @@ def jam_preprocessor( # [dets, T], names=("detector_id", "measurement_end_utc") # ) + print(df) + print( "Dropping detectors with sufficiently high amounts of missing data (>{}%)...".format( percentage_missing @@ -518,6 +521,6 @@ def jam_preprocessor( df["lon"] = df["lon"].interpolate(method="pad", limit_direction="both", axis=0) df["lat"] = df["lat"].interpolate(method="pad", limit_direction="both", axis=0) - df["measurement_start_utc"] = df["measurement_end_utc"] - np.timedelta64(1, "h") + #df["measurement_start_utc"] = df["measurement_end_utc"] - np.timedelta64(1, "h") return df From 19831ac32ae6e583e203f64962b22034fb95012d Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Thu, 20 Aug 2020 14:42:00 +0100 Subject: [PATCH 6/8] MO, MV --- SpatialScan/multi_scoot_gp.py | 265 +++++++++++++++++++++++++++++++++- SpatialScan/preprocessing.py | 9 +- SpatialScan/timeseries.py | 3 +- SpatialScan/timeseriesjam.py | 8 +- 4 files changed, 274 insertions(+), 11 deletions(-) diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index 07abd5e..f752f6b 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -2,7 +2,270 @@ import pandas as pd import numpy as np import gpflow -from gpflow.utilities import print_summary +from gpflow.utilities import print_summary, set_trainable, to_default_float +from sklearn.preprocessing import MinMaxScaler + +class JamCamMVGP: + + def __init__(self): + self.model = None + self.model_training_info = None + self.scaler = None + + def create_dataset(self, single_det_df, target, days): + x = [single_det_df["n_vehicles_in_interval_car"].to_numpy()[:-16*days], + single_det_df["n_vehicles_in_interval_person"].to_numpy()[:-16*days], + single_det_df["n_vehicles_in_interval_bus"].to_numpy()[:-16*days]] + if target == "car": + y = single_det_df["n_vehicles_in_interval_car"].to_numpy()[16*days:] + if target == "person": + y = single_det_df["n_vehicles_in_interval_person"].to_numpy()[16*days:] + if target == "bus": + y = single_det_df["n_vehicles_in_interval_bus"].to_numpy()[16*days:] + return(x, y) + + def train(self, scoot_df, detector, target, days = 3): + single_det_df = scoot_df[scoot_df["detector_id"]==detector] + x, y = self.create_dataset(single_det_df, target, days=days) + scaler_x = MinMaxScaler(feature_range=(-1, 1)) + scaler_y = MinMaxScaler(feature_range=(-1, 1)) + X = np.array(x).T + X = scaler_x.fit_transform(X) + + Y = y.reshape(-1, 1) + Y = Y.astype(float) + Y = scaler_y.fit_transform(Y) + + #print(Y) + kern_w = gpflow.kernels.White(1e-5) + set_trainable(kern_w.variance, False) + kern = gpflow.kernels.Linear() + gpflow.kernels.SquaredExponential(lengthscales=[1, 1, 1]) + + model = gpflow.models.GPR(data=(X, Y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss, + model.trainable_variables, + options=dict(maxiter=100), + ) + + self.model = model + return model, scaler_x, scaler_y + + + def count_baseline(self, train_df, count_df, detectors, target, days=2): + frame_list=[] + for i, detector in enumerate(detectors, 1): + print("please wait: ", i, "/", len(detectors), end="\r") + try: + model, scaler_x, scaler_y = self.train(train_df, detector, target, days=days) + except: + print("uninvertable: ", detector) + continue + single_detector_df = count_df[count_df["detector_id"] == detector] + #print(single_detector_df) + x, y = self.create_dataset(single_detector_df, target, days=days) + X = np.array(x).T + X = scaler_x.fit_transform(X) + mean, var = model.predict_f(X) + # mean = mean.numpy().flatten() + # var = var.numpy().flatten() + mean = scaler_y.inverse_transform(mean).flatten() + var = scaler_y.inverse_transform(var).flatten() + forecast_period = (single_detector_df[single_detector_df["measurement_end_utc"] >= + single_detector_df["measurement_end_utc"].min() + + np.timedelta64(days*24, "h")]["measurement_end_utc"]).to_numpy() + forecast_df = pd.DataFrame( + { + "count": y, + "baseline": mean, + "prediction_variance": var, + "baseline_upper":mean + + 3 * np.sqrt(var), + "baseline_lower": mean + - 3 * np.sqrt(var), + "detector_id": detector, + "lon": single_detector_df[single_detector_df["detector_id"] == detector]["lon"].iloc[0], + "lat": single_detector_df[single_detector_df["detector_id"] == detector]["lat"].iloc[0], + "measurement_end_utc": forecast_period, + } + ) + frame_list.append(forecast_df) + + del model + + return pd.concat(frame_list) + +class JamCamMOGP: + + def __init__(self): + self.model = None + self.model_training_info = None + self.scaler = None + + def train(self, dataset, kern=None, method="GPR", num_induce=50): + """method""" + # set up kernels + if kern is None: + + kern_pD = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_pW = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) + kern_SE = gpflow.kernels.SquaredExponential() + kern_W = gpflow.kernels.White() + kern_M = gpflow.kernels.Matern32() + + kern_pD.period.assign(24.0) + # kern_pD.base_kernel.variance.assign(10) + kern_pW.period.assign(168.0) + # kern_pW.base_kernel.variance.assign(10) + + kern = kern_pD + kern_pW + kern_M + + X = ( + (dataset["measurement_end_utc"] - dataset["measurement_end_utc"].min()) + .astype("timedelta64[h]") + .to_numpy() + .reshape(-1, 1) + ) + + starts = dataset["measurement_end_utc"].min() + ends = dataset["measurement_end_utc"].max() + + Y = [dataset["n_vehicles_in_interval_car"].to_numpy(), dataset["n_vehicles_in_interval_person"].to_numpy(), dataset["n_vehicles_in_interval_bus"].to_numpy()] + + #self.model_training_info = pd.DataFrame({"detector_id" : detectors, "training_start" : starts, "training_end" : ends}) + + Y = np.array(Y) + Y = Y.T + + scaler = MinMaxScaler(feature_range=(-1, 1)) + y = scaler.fit_transform(Y) + + # fit our GP to X & y + if method == "GPR": + model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() + #print("BEFORE OPTIMISATION") + #print_summary(model) + + opt.minimize( + model.training_loss, model.trainable_variables, options=dict(maxiter=10000)) + + if method == "sharedkern": + kern = gpflow.kernels.SharedIndependent(kern, output_dim=3) + Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] + # initialization of inducing input locations (M random points from the training inputs) + Z = Zinit.copy() + iv = gpflow.inducing_variables.SharedIndependentInducingVariables( + gpflow.inducing_variables.InducingPoints(Z)) + # create SVGP model as usual and optimize + model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=3) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss_closure((X, y)), + variables=model.trainable_variables, + method="l-bfgs-b", + options={"disp": True, "maxiter": 10000},) + + if method == "seperatekern": + kern_list = [kern for _ in range(3)] + kern = gpflow.kernels.SeparateIndependent(kern_list) + Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] + # initialization of inducing input locations (M random points from the training inputs) + Z = Zinit.copy() + iv = gpflow.inducing_variables.SharedIndependentInducingVariables( + gpflow.inducing_variables.InducingPoints(Z)) + # create SVGP model as usual and optimize + model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=3) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss_closure((X, y)), + variables=model.trainable_variables, + method="l-bfgs-b", + options={"disp": True, "maxiter": 10000},) + + if method == "coregional": + kern_list = [kern for _ in range(3)] + kern = gpflow.kernels.LinearCoregionalization(kern_list, W=np.random.randn(3, 3)) + Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] + # initialization of inducing input locations (M random points from the training inputs) + Z = Zinit.copy() + iv = gpflow.inducing_variables.SharedIndependentInducingVariables( + gpflow.inducing_variables.InducingPoints(Z)) + # initialize mean of variational posterior to be of shape MxL + q_mu = np.zeros((num_induce, 3)) + # initialize \sqrt(Σ) of variational posterior to be of shape LxMxM + q_sqrt = np.repeat(np.eye(num_induce)[None, ...], 3, axis=0) * 1.0 + model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, q_mu=q_mu, q_sqrt=q_sqrt) + opt = gpflow.optimizers.Scipy() + opt.minimize( + model.training_loss_closure((X, y)), + variables=model.trainable_variables, + method="l-bfgs-b", + options={"disp": True, "maxiter": 10000},) + + #print("AFTER OPTIMISATION") + #print_summary(model) + + self.model = model + self.scaler = scaler + return model, scaler + + def count_baseline(self, train_df, count_df, detectors: list = None, method = "GPR"): + + pd.options.mode.chained_assignment = None + + if detectors is None: + detectors = forecast_scoot_df["detector_id"].drop_duplicates().to_numpy() + + frame_list=[] + for i, detector in enumerate(detectors, 1): + + single_detector_train = train_df[train_df["detector_id"]==detector] + print("please wait: ", i, "/", len(detectors), end="\r") + + model, scaler = self.train(single_detector_train, method=method) + if model is None: + print("uninvertable: ", detector) + continue + + single_detector_count = count_df[count_df["detector_id"] == detector] + + X = ((single_detector_count["measurement_end_utc"] - single_detector_train["measurement_end_utc"].min()) + .astype("timedelta64[h]") + .to_numpy() + .reshape(-1, 1)) + + car = single_detector_count["n_vehicles_in_interval_car"].to_numpy() + person = single_detector_count["n_vehicles_in_interval_person"].to_numpy() + + mean, var = model.predict_f(X) + mean = scaler.inverse_transform(mean) + var = scaler.inverse_transform(var) + mean = mean.T + var = var.T + + forecast_df = pd.DataFrame( + { + "count": car, + "baseline": mean[0], + "prediction_variance": var[0], + "baseline_upper":mean[0] + + 3 * np.sqrt(var[0]), + "baseline_lower": mean[0] + - 3 * np.sqrt(var[0]), + "detector_id": detector, + "lon": single_detector_count[single_detector_count["detector_id"] == detector]["lon"].iloc[0], + "lat": single_detector_count[single_detector_count["detector_id"] == detector]["lat"].iloc[0], + "measurement_end_utc": single_detector_count["measurement_end_utc"] + } + ) + frame_list.append(forecast_df) + + del model + + return pd.concat(frame_list) + class MultiVariateGP: diff --git a/SpatialScan/preprocessing.py b/SpatialScan/preprocessing.py index 991611b..8dd0c7e 100644 --- a/SpatialScan/preprocessing.py +++ b/SpatialScan/preprocessing.py @@ -452,11 +452,16 @@ def jam_preprocessor( orig_length = len(orig_set) + print("Dropping detectors with more than {} anomalies...".format(max_anom)) df = df.drop(df[df["Num_Anom"] > max_anom].index) - + + print(df.index, mux) df = df.reindex(mux) + print(df) + + x = [] for d in df.index.get_level_values("detector_id").unique(): x.append([df.loc[d]["n_vehicles_in_interval"].isna().sum()] * len(df.loc[d])) @@ -472,7 +477,7 @@ def jam_preprocessor( # [dets, T], names=("detector_id", "measurement_end_utc") # ) - print(df) + print( "Dropping detectors with sufficiently high amounts of missing data (>{}%)...".format( diff --git a/SpatialScan/timeseries.py b/SpatialScan/timeseries.py index b69e53c..e7bd0e7 100644 --- a/SpatialScan/timeseries.py +++ b/SpatialScan/timeseries.py @@ -710,8 +710,7 @@ def count_baseline( # Add check for Nans cleanse count_nans = forecast_df["count"].isnull().sum(axis=0) baseline_nans = forecast_df["baseline"].isnull().sum(axis=0) - assert count_nans == 0 - assert baseline_nans == 0 + # Make Baseline Values Non-Negative negative = len(forecast_df[forecast_df["baseline"] < 0]["baseline"]) diff --git a/SpatialScan/timeseriesjam.py b/SpatialScan/timeseriesjam.py index fcecec3..03b7d16 100644 --- a/SpatialScan/timeseriesjam.py +++ b/SpatialScan/timeseriesjam.py @@ -47,6 +47,8 @@ def holt_wintersJ( one_D = df[df["detector_id"] == detector] one_D = one_D.sort_values(by=["measurement_end_utc"]) past = one_D.tail(n=16 * days_in_past) + shift = 19 - past["measurement_end_utc"].min().hour + past = past[past["measurement_end_utc"]>past["measurement_end_utc"].min() + np.timedelta64(shift, "h")] for i in range(0, len(past)): h = i % 16 c = past["n_vehicles_in_interval"].iloc[i] @@ -213,12 +215,6 @@ def count_baselineJ( forecast_df["baseline"] = forecast_df["baseline"].apply( lambda x: np.max([0, x]) ) - forecast_df["baseline_upper"] = forecast_df["baseline_upper"].apply( - lambda x: np.max([0, x]) - ) - forecast_df["baseline_lower"] = forecast_df["baseline_lower"].apply( - lambda x: np.max([0, x]) - ) # T = pd.date_range( # start=Y["measurement_end_utc"].min() - np.timedelta64(3, "h"), From ff301439f5e6b3b4f8bfaac230ff4df159b2bbd6 Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Thu, 20 Aug 2020 16:30:47 +0100 Subject: [PATCH 7/8] MO, MV --- SpatialScan/multi_scoot_gp.py | 129 ++++++++++++++++++++++++++++------ 1 file changed, 108 insertions(+), 21 deletions(-) diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index f752f6b..70d9068 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -6,6 +6,9 @@ from sklearn.preprocessing import MinMaxScaler class JamCamMVGP: + """A class for producing AutoRegressive Multivaraite GP forecasts for JamCam's, where + Multiple GP models are used to make forecast of the counts in the future (Y) based on + the number of counts in the past (X)""" def __init__(self): self.model = None @@ -13,9 +16,23 @@ def __init__(self): self.scaler = None def create_dataset(self, single_det_df, target, days): + """organises data into autoregressive form. x and y are both count data, out of sync + by the number of days specified in the argument days + + Args: + single_det_df: jamcam dataframe of count data for one detector + target: the class we wish to predict, either "car", "person" or "bus" + days: the number of days by which to shift x & y out of sync, this will also + be allowable length of your forecasting period + Returns: + x, y : Count data out of sync by number of days for training autoregression + """ + + # y is composed of all classes and is "days" number of days behind y x = [single_det_df["n_vehicles_in_interval_car"].to_numpy()[:-16*days], single_det_df["n_vehicles_in_interval_person"].to_numpy()[:-16*days], single_det_df["n_vehicles_in_interval_bus"].to_numpy()[:-16*days]] + if target == "car": y = single_det_df["n_vehicles_in_interval_car"].to_numpy()[16*days:] if target == "person": @@ -24,11 +41,26 @@ def create_dataset(self, single_det_df, target, days): y = single_det_df["n_vehicles_in_interval_bus"].to_numpy()[16*days:] return(x, y) - def train(self, scoot_df, detector, target, days = 3): - single_det_df = scoot_df[scoot_df["detector_id"]==detector] + def train(self, jam_df, detector, target, days = 3): + """trains a model for a single scoot detector, and returns along with x and y scalers + Args: + jam_df: jamcam dataframe of count data for multiple detectors + detector: detector id to build model for + target: the class we wish to predict, either "car", "person" or "bus" + days: the number of days by which to shift x & y out of sync, this will also + be allowable length of your forecasting period + Returns: + model : GP flow model + scaler_x, scaler_y: min_max scalers for x & y respectively""" + + single_det_df = jam_df[jam_df["detector_id"]==detector] x, y = self.create_dataset(single_det_df, target, days=days) + + #double scaler seems to resolve matrix inversion best (WHY?!) scaler_x = MinMaxScaler(feature_range=(-1, 1)) scaler_y = MinMaxScaler(feature_range=(-1, 1)) + + #organise data into gpflow friendly form X = np.array(x).T X = scaler_x.fit_transform(X) @@ -39,9 +71,12 @@ def train(self, scoot_df, detector, target, days = 3): #print(Y) kern_w = gpflow.kernels.White(1e-5) set_trainable(kern_w.variance, False) + + #linear plus RBF works well for autoregression kern = gpflow.kernels.Linear() + gpflow.kernels.SquaredExponential(lengthscales=[1, 1, 1]) model = gpflow.models.GPR(data=(X, Y), kernel=kern, mean_function=None) + opt = gpflow.optimizers.Scipy() opt.minimize( model.training_loss, @@ -54,6 +89,17 @@ def train(self, scoot_df, detector, target, days = 3): def count_baseline(self, train_df, count_df, detectors, target, days=2): + """produces a count_baseline dataframe, given a training set, and a test set + Args: + train_df: dataframe of jamcam data to train models on + count_df: dataframe of jamcam data to validate model against + detectors: list of detectors to produce count_baseline from + target: the class we wish to predict, either "car", "person" or "bus" + days: the number of days by which to shift x & y out of sync, this will also + be allowable length of your forecasting period + Returns: + count_baseline style dataframe""" + frame_list=[] for i, detector in enumerate(detectors, 1): print("please wait: ", i, "/", len(detectors), end="\r") @@ -97,15 +143,25 @@ def count_baseline(self, train_df, count_df, detectors, target, days=2): return pd.concat(frame_list) class JamCamMOGP: - + """ A class for producing Multioutput JamCam models""" def __init__(self): self.model = None self.model_training_info = None self.scaler = None def train(self, dataset, kern=None, method="GPR", num_induce=50): - """method""" - # set up kernels + """trains a model for a single scoot detector, and returns along with y scaler + + Args: + dataset: jamcam dataframe of count data for single + kern: optional kernel choice + method: method of multioutput GP + num_induce: number of inducing points for SVGPs + Returns: + model : GP flow model + scaler: min_max scalers for count data""" + + # set up kernels, two periodics plus matern works well if kern is None: kern_pD = gpflow.kernels.Periodic(gpflow.kernels.SquaredExponential()) @@ -120,7 +176,8 @@ def train(self, dataset, kern=None, method="GPR", num_induce=50): # kern_pW.base_kernel.variance.assign(10) kern = kern_pD + kern_pW + kern_M - + + #produce X data X = ( (dataset["measurement_end_utc"] - dataset["measurement_end_utc"].min()) .astype("timedelta64[h]") @@ -131,34 +188,37 @@ def train(self, dataset, kern=None, method="GPR", num_induce=50): starts = dataset["measurement_end_utc"].min() ends = dataset["measurement_end_utc"].max() + #produce multidimensional Y data Y = [dataset["n_vehicles_in_interval_car"].to_numpy(), dataset["n_vehicles_in_interval_person"].to_numpy(), dataset["n_vehicles_in_interval_bus"].to_numpy()] - #self.model_training_info = pd.DataFrame({"detector_id" : detectors, "training_start" : starts, "training_end" : ends}) - + # put Y data in gpflow friendly form Y = np.array(Y) Y = Y.T scaler = MinMaxScaler(feature_range=(-1, 1)) y = scaler.fit_transform(Y) - # fit our GP to X & y + # basic GPR method, all Y are treated independently (is this definately true?) if method == "GPR": model = gpflow.models.GPR(data=(X, y), kernel=kern, mean_function=None) opt = gpflow.optimizers.Scipy() - #print("BEFORE OPTIMISATION") - #print_summary(model) + opt.minimize( model.training_loss, model.trainable_variables, options=dict(maxiter=10000)) + # shared kernel SVGP, which the outputs of outputs directly. Mixing matrix W = I + # the priors on outputs have the same kernel hyperparameters and inducing points + # The different GPs have independent priors and posteriors. if method == "sharedkern": + #shared independent kernel kern = gpflow.kernels.SharedIndependent(kern, output_dim=3) Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] - # initialization of inducing input locations (M random points from the training inputs) + # initialization of inducing input locations (random points from the training inputs) Z = Zinit.copy() iv = gpflow.inducing_variables.SharedIndependentInducingVariables( gpflow.inducing_variables.InducingPoints(Z)) - # create SVGP model as usual and optimize + # create SVGP model and optimize model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=3) opt = gpflow.optimizers.Scipy() opt.minimize( @@ -167,15 +227,20 @@ def train(self, dataset, kern=None, method="GPR", num_induce=50): method="l-bfgs-b", options={"disp": True, "maxiter": 10000},) + # shared kernel SVGP, which the outputs of outputs directly. Mixing matrix W = I + # the priors on outputs have the different kernel hyperparameters but the same + # inducing points. The different GPs have independent priors and posteriors. if method == "seperatekern": + # create list of seperate independent kernels kern_list = [kern for _ in range(3)] + # create a seprate independent kernel type kern = gpflow.kernels.SeparateIndependent(kern_list) Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] - # initialization of inducing input locations (M random points from the training inputs) + # initialization of inducing input locations Z = Zinit.copy() iv = gpflow.inducing_variables.SharedIndependentInducingVariables( gpflow.inducing_variables.InducingPoints(Z)) - # create SVGP model as usual and optimize + # create SVGP, optimize model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, num_latent_gps=3) opt = gpflow.optimizers.Scipy() opt.minimize( @@ -183,19 +248,28 @@ def train(self, dataset, kern=None, method="GPR", num_induce=50): variables=model.trainable_variables, method="l-bfgs-b", options={"disp": True, "maxiter": 10000},) - + + # full mixing via linear coregionalisation. by mising the outputs in W they become correlated. + # we use number number of laten GPs equal to the number of outputs, but in practise it could + # be smaller (we only have 3 outputs) if method == "coregional": + #create list of kernels kern_list = [kern for _ in range(3)] + #produce coregionalisation kernel kern = gpflow.kernels.LinearCoregionalization(kern_list, W=np.random.randn(3, 3)) + + #initialise shared inducing points Zinit = np.linspace(X.min(), X.max(), num_induce)[:, None] - # initialization of inducing input locations (M random points from the training inputs) Z = Zinit.copy() iv = gpflow.inducing_variables.SharedIndependentInducingVariables( gpflow.inducing_variables.InducingPoints(Z)) - # initialize mean of variational posterior to be of shape MxL + + # initialize mean of variational posterior to be of shape num_inducex3 q_mu = np.zeros((num_induce, 3)) - # initialize \sqrt(Σ) of variational posterior to be of shape LxMxM + + # initialize \sqrt(Σ) of variational posterior to be of shape 3xnum_induce**2 q_sqrt = np.repeat(np.eye(num_induce)[None, ...], 3, axis=0) * 1.0 + #produce SVGP and optimse model = gpflow.models.SVGP(kern, gpflow.likelihoods.Gaussian(), inducing_variable=iv, q_mu=q_mu, q_sqrt=q_sqrt) opt = gpflow.optimizers.Scipy() opt.minimize( @@ -211,7 +285,19 @@ def train(self, dataset, kern=None, method="GPR", num_induce=50): self.scaler = scaler return model, scaler - def count_baseline(self, train_df, count_df, detectors: list = None, method = "GPR"): + def count_baseline(self, train_df, count_df, detectors: list = None, method = "GPR", num_induce=50): + """produces a count_baseline dataframe, given a training set, and a test set. In our case we only + look at cars but that choice is arbitary + Args: + train_df: dataframe of jamcam data to train models on + count_df: dataframe of jamcam data to validate model against + detectors: list of detectors to produce count_baseline from + method: method of multioutput GP + num_induce: number of inducing points for SVGPs + + Returns: + count_baseline style dataframe""" + pd.options.mode.chained_assignment = None @@ -224,7 +310,7 @@ def count_baseline(self, train_df, count_df, detectors: list = None, method = "G single_detector_train = train_df[train_df["detector_id"]==detector] print("please wait: ", i, "/", len(detectors), end="\r") - model, scaler = self.train(single_detector_train, method=method) + model, scaler = self.train(single_detector_train, method=method, num_induce=num_induce) if model is None: print("uninvertable: ", detector) continue @@ -266,6 +352,7 @@ def count_baseline(self, train_df, count_df, detectors: list = None, method = "G return pd.concat(frame_list) +## What follows is a list of similar functions, but for scoot- these require extra work (I think) class MultiVariateGP: From 643f57c7a8311be26d4ccb300b437fbf807b1f10 Mon Sep 17 00:00:00 2001 From: TeddyTW <65396509+TeddyTW@users.noreply.github.com> Date: Thu, 20 Aug 2020 18:13:52 +0100 Subject: [PATCH 8/8] notebook for MO --- SpatialScan/multi_scoot_gp.py | 3 +- notebooks/Multivariate.ipynb | 609 ++++++++++++++++++++++++++++++++++ 2 files changed, 610 insertions(+), 2 deletions(-) create mode 100644 notebooks/Multivariate.ipynb diff --git a/SpatialScan/multi_scoot_gp.py b/SpatialScan/multi_scoot_gp.py index 70d9068..38dc52b 100644 --- a/SpatialScan/multi_scoot_gp.py +++ b/SpatialScan/multi_scoot_gp.py @@ -25,8 +25,7 @@ def create_dataset(self, single_det_df, target, days): days: the number of days by which to shift x & y out of sync, this will also be allowable length of your forecasting period Returns: - x, y : Count data out of sync by number of days for training autoregression - """ + x, y : Count data out of sync by number of days for training autoregression""" # y is composed of all classes and is "days" number of days behind y x = [single_det_df["n_vehicles_in_interval_car"].to_numpy()[:-16*days], diff --git a/notebooks/Multivariate.ipynb b/notebooks/Multivariate.ipynb new file mode 100644 index 0000000..a15e8ed --- /dev/null +++ b/notebooks/Multivariate.ipynb @@ -0,0 +1,609 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multitask Notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import gpflow as gpf\n", + "import tensorflow as tf\n", + "import gpflow\n", + "import tensorflow as tf\n", + "import time\n", + "\n", + "from SpatialScan.preprocessing import *\n", + "from SpatialScan.multi_scoot_gp import *\n", + "from gpflow.utilities import print_summary\n", + "from gpflow.ci_utils import ci_niter\n", + "\n", + "gpf.config.set_default_float(np.float64)\n", + "gpf.config.set_default_summary_fmt(\"notebook\")\n", + "np.random.seed(0)\n", + "%matplotlib inline\n", + "from SpatialScan.timeseries import *\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "MAXITER = ci_niter(2000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read in our JamCam Data, it has already been preprocessed, so the data should be fairly \"well behaved\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multivariate Autoregressive GP for Jamcams" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "DF = pd.read_csv('multi_jam2.csv', index_col=False, parse_dates=[4, 5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialise our Multivaraite Jamcam class" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "MVGP=JamCamMVGP()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Produce a training and test set from the data" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "prediction_start = DF[\"measurement_end_utc\"].max() - np.timedelta64(4, \"D\") + np.timedelta64(2, \"h\")\n", + "train = DF[DF[\"measurement_end_utc\"]<= prediction_start]\n", + "test = DF[DF[\"measurement_end_utc\"] > prediction_start]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To see the format of the Auroregressive data, lets convert the test set into autoregressive data to observe it" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 46)\n", + "46\n" + ] + } + ], + "source": [ + "#create dataset for one detector\n", + "test1 = test[test[\"detector_id\"]==test[\"detector_id\"].unique()[0]]\n", + "train1 = train[train[\"detector_id\"]==train[\"detector_id\"].unique()[0]]\n", + "\n", + "x, y = MVGP.create_dataset(test1, \"car\", days = 1)\n", + "print(np.array(x).shape)\n", + "print(len(y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see above, X has the same length as y, with 3 columns. We now show in the plot below at how the x and y arre the same data, but y is ahead by one day" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x[0]) #x[0] is the cars\n", + "plt.show()\n", + "plt.plot(y)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "lets train a model for the same detector, using the training data. the train method returns the trained model along with scalers" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "model, scaler_x, scaler_y = MVGP.train(train, test[\"detector_id\"].unique()[0], \"car\", days = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform prior trainable shape dtype value
GPR.kernel.kernels[0].variance ParameterSoftplus True () float640.12115256574330223
GPR.kernel.kernels[1].variance ParameterSoftplus True () float640.012845064294557694
GPR.kernel.kernels[1].lengthscalesParameterSoftplus True (3,) float64[1.43407431 0.83786813 1.25700751]
GPR.likelihood.variance ParameterSoftplus + Shift True () float640.07608869028567625
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "now lets use our model to see if we can predict y from x" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "X = np.array(x).T\n", + "X = scaler_x.fit_transform(X)\n", + "mean, var = model.predict_f(X)\n", + "# mean = mean.numpy().flatten()\n", + "# var = var.numpy().flatten()\n", + "mean = scaler_y.inverse_transform(mean).flatten()\n", + "var = scaler_y.inverse_transform(var).flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot\n", + "plt.plot(mean, label= \"prediction\")\n", + "plt.plot(y, label= \"actual\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This can all be automated for multiple detectors at once, and validated against actual counts, by calling count_baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "please wait: 1 / 1\r" + ] + } + ], + "source": [ + "CB2 = MVGP.count_baseline(train, test, detectors=[train[\"detector_id\"].unique()[0]], target=\"car\", days=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.01251\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "forecast_plot(CB2)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "31.994070940387008" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MAPE(CB2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multioutput GP for Jamcams" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "first imitialise JamcamMOGP object" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "MOGP=JamCamMOGP()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because this doesn't use autoregressive data, we can go straight in and train our model for one jamcam" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "model, scaler = MOGP.train(train1, method = \"coregional\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our model has a lot of hyper parameters, does to the mixing matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform prior trainable shape dtype value
SVGP.kernel.kernels[0].kernels[0].base_kernel.variance\n", + "SVGP.kernel.kernels[1].kernels[0].base_kernel.variance\n", + "SVGP.kernel.kernels[2].kernels[0].base_kernel.variance ParameterSoftplus True () float641.4733135653472766
SVGP.kernel.kernels[0].kernels[0].base_kernel.lengthscales\n", + "SVGP.kernel.kernels[1].kernels[0].base_kernel.lengthscales\n", + "SVGP.kernel.kernels[2].kernels[0].base_kernel.lengthscales ParameterSoftplus True () float640.4469462541205632
SVGP.kernel.kernels[0].kernels[0].period\n", + "SVGP.kernel.kernels[1].kernels[0].period\n", + "SVGP.kernel.kernels[2].kernels[0].period ParameterSoftplus True () float6424.154941733475766
SVGP.kernel.kernels[0].kernels[1].base_kernel.variance\n", + "SVGP.kernel.kernels[1].kernels[1].base_kernel.variance\n", + "SVGP.kernel.kernels[2].kernels[1].base_kernel.variance ParameterSoftplus True () float640.34686797170758654
SVGP.kernel.kernels[0].kernels[1].base_kernel.lengthscales\n", + "SVGP.kernel.kernels[1].kernels[1].base_kernel.lengthscales\n", + "SVGP.kernel.kernels[2].kernels[1].base_kernel.lengthscales ParameterSoftplus True () float640.9203736338496251
SVGP.kernel.kernels[0].kernels[1].period\n", + "SVGP.kernel.kernels[1].kernels[1].period\n", + "SVGP.kernel.kernels[2].kernels[1].period ParameterSoftplus True () float64176.53821090779533
SVGP.kernel.kernels[0].kernels[2].variance\n", + "SVGP.kernel.kernels[1].kernels[2].variance\n", + "SVGP.kernel.kernels[2].kernels[2].variance ParameterSoftplus True () float640.5668359423882156
SVGP.kernel.kernels[0].kernels[2].lengthscales\n", + "SVGP.kernel.kernels[1].kernels[2].lengthscales\n", + "SVGP.kernel.kernels[2].kernels[2].lengthscales ParameterSoftplus True () float648.642951521402214
SVGP.kernel.W Parameter True (3, 3) float64[[-0.27927027, 0.00489013, -0.19452441...
SVGP.likelihood.variance ParameterSoftplus + Shift True () float640.06120140919669867
SVGP.inducing_variable.inducing_variable.ZParameter True (50, 1) float64[[-2.63270346e-01...
SVGP.q_mu Parameter True (50, 3) float64[[0.44976684, -0.39087329, -1.83371996...
SVGP.q_sqrt ParameterFillTriangular True (3, 50, 50)float64[[[2.17357439e-01, 0.00000000e+00, 0.00000000e+00...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Now form prediction of test set, and compare to actual counts" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "X = ((test1[\"measurement_end_utc\"] - train1[\"measurement_end_utc\"].min())\n", + " .astype(\"timedelta64[h]\")\n", + " .to_numpy()\n", + " .reshape(-1, 1))\n", + "mean, var = model.predict_f(X)\n", + "mean = scaler.inverse_transform(mean)\n", + "var = scaler.inverse_transform(var)\n", + "mean=mean.T" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(mean[0])\n", + "plt.plot(test1[\"n_vehicles_in_interval_car\"].to_numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we can automate this process with count baseline, and compare using the plot forecast. This can handle multiple detectors at once" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "please wait: 1 / 1\r" + ] + } + ], + "source": [ + "CB=MOGP.count_baseline(train, test, detectors=[train[\"detector_id\"].unique()[0]], method=\"coregional\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "def MAPE(df):\n", + " return 100*(abs((df[df[\"count\"]>0][\"count\"]-df[df[\"count\"]>0][\"baseline\"])/df[df[\"count\"]>0][\"count\"]).mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "28.873871952504654" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MAPE(CB)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.01251\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "forecast_plot(CB)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}