def _create_models(self, X, y):
if len(y.shape) == 1:
n_outputs = 1
else:
raise ValueError(
'Only scalar predictions are currently supported.')
self.models_ = []
if self.backend_ == 'sklearn':
from sklearn.neural_network import MLPRegressor
for model_idx in range(self.n_regressors_):
model = MLPRegressor(
hidden_layer_sizes=self.layer_sizes_list_[model_idx],
activation=self.activations_[model_idx],
solver=self.solvers_[model_idx],
alpha=self.alphas_[model_idx],
batch_size=self.batch_sizes_[model_idx],
max_iter=self.max_iters_[model_idx],
momentum=self.momentums_[model_idx],
nesterovs_momentum=self.nesterovs_momentums_[model_idx],
verbose=self.verbose_,
)
self.models_.append(model)
elif self.backend_ == 'keras':
from keras import regularizers
from keras.layers import Dense
from keras.models import Sequential
for model_idx in range(self.n_regressors_):
hidden_layer_sizes = self.layer_sizes_list_[model_idx]
model = Sequential()
for layer_size in hidden_layer_sizes:
model.add(
Dense(layer_size,
kernel_initializer='normal',
activation=self.activations_[model_idx],
kernel_regularizer=regularizers.l2(0.01)))
if self.loss_ == 'mse':
model.add(
Dense(1,
kernel_initializer='normal',
kernel_regularizer=regularizers.l2(0.01)))
model.compile(loss='mean_squared_error',
optimizer=self.solvers_[model_idx])
elif self.loss_ == 'gaussian_nll':
model.add(
Dense(2,
kernel_initializer='normal',
kernel_regularizer=regularizers.l2(0.01)))
model.compile(loss=gaussian_nll,
optimizer=self.solvers_[model_idx])
self.models_.append(model)
def RunIterativePredict(FeaturesDFin, currentStep):
FeaturesDF = FeaturesDFin.copy()
FeaturesDF_raw = FeaturesDF.copy()
if Settings["Normalise"] == "Yes":
for col in FeaturesDF.columns:
FeaturesDF[col] = (
FeaturesDF[col] -
FeaturesDF_raw[col].mean()) / FeaturesDF_raw[col].std()
if Settings["Regressor"] == "NN":
nn_options = { # options for neural network
'hidden_layer_sizes': (2, 1),
'solver': 'lbfgs',
'activation': 'tanh',
'max_iter': 1500, # default 200
'alpha': 0.001, # default 0.0001
'random_state': None # default None
}
model = MLPRegressor(**nn_options)
elif Settings["Regressor"] == "GPR":
mainRolling_kernel = ConstantKernel() + Matern() + DotProduct(
) + WhiteKernel() # + PairwiseKernel() + RBF() + ExpSineSquared()
#mainRolling_kernel = 1**2*ConstantKernel() + 1**2*Matern() + 1**2*DotProduct() + 1**2* ExpSineSquared() + 1**2*WhiteKernel() # + PairwiseKernel() + RBF() + ExpSineSquared()
model = GaussianProcessRegressor(
kernel=mainRolling_kernel,
random_state=0,
n_restarts_optimizer=2) #, normalize_y=True
elif Settings["Regressor"] == "LSTM":
model = Sequential()
model.add(LSTM(7, input_shape=(1, FeaturesDF.shape[1])))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
iterPredsList = []
iterPreds_Std_List = []
if "SingleStepPredict" in Settings["Reporter"]:
fitInputX = FeaturesDF.shift(1).bfill().values
fitTargetY = FeaturesDF[targetVarName].values.reshape(-1, 1)
if Settings["Regressor"] == "LSTM":
fitInputX = fitInputX.reshape(trainX, (1, FeaturesDF.shape[1]))
for i in range(10):
model.fit(fitInputX,
fitTargetY,
epochs=1,
batch_size=5,
verbose=0,
shuffle=False)
model.reset_states()
else:
model.fit(fitInputX, fitTargetY)
if Settings['Regressor'] in ["NN", "LSTM"]:
firstPred = model.predict(FeaturesDF.iloc[-1].values.reshape(
1, -1))[0]
firstPred_Std = 0
elif Settings['Regressor'] == "GPR":
firstPred, firstPred_Std = model.predict(
FeaturesDF.iloc[-1].values.reshape(1, -1), return_std=True)
firstPred = firstPred[0][0]
firstPred_Std = firstPred_Std[0]
iterPredsList.append(firstPred)
iterPreds_Std_List.append(firstPred_Std)
elif "Iterative" in Settings["Reporter"]:
"Iterative Predictions"
inputDataList_rep = []
for j in range(Settings["predictAhead"] - 1):
if j == 0:
fitInputX = FeaturesDF.shift(1).bfill().values
fitTargetY = FeaturesDF[targetVarName].values.reshape(
-1, 1)
if Settings["Regressor"] == "LSTM":
fitInputX = np.reshape(fitInputX,
(1, FeaturesDF.shape[1]))
for i in range(10):
model.fit(fitInputX,
fitTargetY,
epochs=1,
batch_size=1,
verbose=0,
shuffle=False)
model.reset_states()
else:
model.fit(fitInputX, fitTargetY)
if Settings['Regressor'] in ["NN", "LSTM"]:
firstPred = model.predict(
FeaturesDF.iloc[-1].values.reshape(1, -1))[0]
firstPred_Std = 0
elif Settings['Regressor'] == "GPR":
firstPred, firstPred_Std = model.predict(
FeaturesDF.iloc[-1].values.reshape(1, -1),
return_std=True)
#print(firstPred)
#print(firstPred_Std)
#time.sleep(3000)
firstPred = firstPred[0][0]
firstPred_Std = firstPred_Std[0]
iterPredsList.append(firstPred)
iterPreds_Std_List.append(firstPred_Std)
expanding_infectedDF = infectedDF.copy().iloc[:currentStep +
j + 1]
newDate = expanding_infectedDF.index[-1]
knownWeather = allWeatherDF.loc[newDate].values
knownMobility = mobility_df.loc[newDate]
if Settings["Normalise"] == "Yes":
invertNormIterPreds = [
x * FeaturesDF_raw[targetVarName].std() +
FeaturesDF_raw[targetVarName].mean()
for x in iterPredsList
]
else:
invertNormIterPreds = iterPredsList
expanding_infectedDF.iloc[-len(iterPredsList):] = np.array(
invertNormIterPreds)
expanding_infectedDF_shifted = getShifts(
expanding_infectedDF, Settings['lags'])
if Settings["Scenario"] <= 1:
inputDataList = [invertNormIterPreds[-1]]
for elem in expanding_infectedDF_shifted.iloc[-1]:
inputDataList.append(elem)
for elem in knownWeather:
inputDataList.append(elem)
inputDataList.append(knownMobility)
elif Settings["Scenario"] in [2, 3]:
inputDataList = [invertNormIterPreds[-1]]
for elem in expanding_infectedDF_shifted.iloc[-1]:
inputDataList.append(elem)
elif Settings["Scenario"] == 4:
inputDataList = [invertNormIterPreds[-1]]
inputDataList.append(knownMobility)
elif Settings["Scenario"] == 5:
inputDataList = [invertNormIterPreds[-1]]
for elem in knownWeather:
inputDataList.append(elem)
inputDataList_rep.append([newDate, str(inputDataList)])
if Settings["Normalise"] == "Yes":
for colCount in range(len(FeaturesDF_raw.columns)):
inputDataList[colCount] = (
inputDataList[colCount] -
FeaturesDF_raw.iloc[:, colCount].mean()
) / FeaturesDF_raw.iloc[:, colCount].std()
if Settings["Regressor"] == "NN":
inputPointArray = np.array(inputDataList)
iterPred = model.predict(inputPointArray.reshape(1, -1))[0]
iterPred_std = 0
else:
inputPointArray = np.array(inputDataList)
iterPred, iterPred_std = model.predict(
inputPointArray.reshape(1, -1), return_std=True)
iterPred = iterPred[0][0]
iterPred_std = iterPred_std[0]
iterPredsList.append(iterPred)
iterPreds_Std_List.append(iterPred_std)
iterPredsList.insert(0, FeaturesDF_raw.index[-1])
iterPreds_Std_List.insert(0, FeaturesDF_raw.index[-1])
if Settings["Normalise"] == "Yes":
"standard normalisation"
iterPredsList[1:] = [
x * FeaturesDF_raw[targetVarName].std() +
FeaturesDF_raw[targetVarName].mean() for x in iterPredsList[1:]
]
iterPreds_Std_List[1:] = [
x * FeaturesDF_raw[targetVarName].std()
for x in iterPreds_Std_List[1:]
]
if (Settings["Scenario"] == 1) & (RegionName
in ["Campania", "Lombardia"]):
pd.concat([expanding_infectedDF, infectedDF.loc[expanding_infectedDF.index], allWeatherDF.loc[expanding_infectedDF.index], mobility_df.loc[expanding_infectedDF.index], pd.DataFrame(inputDataList_rep, columns=['data', 'inputs']).set_index('data', )], axis=1)\
.to_excel(modelDataPath+str(Settings["Scenario"])+RegionName+"_expanding_infectedDF.xlsx")
return [iterPredsList, iterPreds_Std_List]
def perform_fit(self,
amp,
pixel_pos,
training_library,
max_fitpoints=None,
nodes=(64, 64, 64, 64, 64, 64, 64, 64, 64)):
"""
Fit MLP model to individual template pixels
:param amp: ndarray
Pixel amplitudes
:param pixel_pos: ndarray
Pixel XY coordinate format (N, 2)
:param max_fitpoints: int
Maximum number of points to include in MLP fit
:param nodes: tuple
Node layout of MLP
:return: MLP
Fitted MLP model
"""
pixel_pos = pixel_pos.T
# If we put a limit on this then randomly choose points
if max_fitpoints is not None and amp.shape[0] > max_fitpoints:
indices = np.arange(amp.shape[0])
np.random.shuffle(indices)
amp = amp[indices[:max_fitpoints]]
pixel_pos = pixel_pos[indices[:max_fitpoints]]
if self.verbose:
print("Fitting template using", training_library, "with",
amp.shape[0], "total pixels")
# We need a large number of layers to get this fit right
if training_library == "sklearn":
from sklearn.neural_network import MLPRegressor
model = MLPRegressor(hidden_layer_sizes=nodes,
activation="relu",
max_iter=1000,
tol=0,
early_stopping=True,
verbose=False,
n_iter_no_change=10)
pixel_pos = np.array([pixel_pos.T[0], np.abs(pixel_pos.T[1])]).T
pixel_pos_neg = np.array(
[pixel_pos.T[0], -1 * np.abs(pixel_pos.T[1])]).T
pixel_pos = np.concatenate((pixel_pos, pixel_pos_neg))
amp = np.concatenate((amp, amp))
model.fit(pixel_pos, amp)
elif training_library == "KNN":
from sklearn.neighbors import KNeighborsRegressor
model = KNeighborsRegressor(50)
model.fit(pixel_pos, amp)
elif training_library == "keras":
from keras.models import Sequential
from keras.layers import Dense
import keras
model = Sequential()
model.add(Dense(nodes[0], activation="relu", input_shape=(2, )))
for n in nodes[1:]:
model.add(Dense(n, activation="relu"))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer="adam", metrics=['accuracy'])
stopping = keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=0.0,
patience=50,
verbose=2,
mode='auto')
model.fit(pixel_pos,
amp,
epochs=10000,
batch_size=50000,
callbacks=[stopping],
validation_split=0.1,
verbose=0)
return model
load_dh=np.reshape(load_h,(365,-1),order='C')
X=np.arange(0,np.size(load_dh, axis=0))
seed=0
np.random.seed(seed)
#create model
print('creating model')
model = Sequential()
model.add(Dense(100, input_dim=1, init='uniform', activation='relu'))
model.add(Dense(24, init='uniform', activation='sigmoid'))
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mean_squared_error'])
# training
print('Training')
model.fit(X, load_dh, batch_size=10, nb_epoch=10000, verbose=2, validation_split=0.3, shuffle=True)
scores = model.evaluate(X, load_dh)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]))
# Multilayer Perceptron to Predict International Airline Passengers (t+1, given t, t-1, t-2)
import numpy
def perform_fit(self, amp, pixel_pos, training_library, max_fitpoints=None,
nodes=(64, 64, 64, 64, 64, 64, 64, 64, 64)):
"""
Fit MLP model to individual template pixels
:param amp: ndarray
Pixel amplitudes
:param pixel_pos: ndarray
Pixel XY coordinate format (N, 2)
:param max_fitpoints: int
Maximum number of points to include in MLP fit
:param nodes: tuple
Node layout of MLP
:return: MLP
Fitted MLP model
"""
pixel_pos = pixel_pos.T
# If we put a limit on this then randomly choose points
if max_fitpoints is not None and amp.shape[0] > max_fitpoints:
indices = np.arange(amp.shape[0])
np.random.shuffle(indices)
amp = amp[indices[:max_fitpoints]]
pixel_pos = pixel_pos[indices[:max_fitpoints]]
if self.verbose:
print("Fitting template using", training_library, "with", amp.shape[0],
"total pixels")
# We need a large number of layers to get this fit right
if training_library == "sklearn":
from sklearn.neural_network import MLPRegressor
model = MLPRegressor(hidden_layer_sizes=nodes, activation="relu",
max_iter=1000, tol=0,
early_stopping=True, verbose=False,
n_iter_no_change=10)
model.fit(pixel_pos, amp)
elif training_library == "kde":
from KDEpy import FFTKDE
from scipy.interpolate import LinearNDInterpolator
x, y = pixel_pos.T
data = np.vstack((x, y, amp))
#print(data.shape)
kde = FFTKDE(bw=0.015).fit(data.T)
points, out = kde.evaluate((self.bins[0], self.bins[1], 200))
points_x, points_y, points_z = points.T
#print(points_z.shape, points, out.shape)
av_z = np.average(points_z)
# print(av_z, ((np.max(points_z)-np.min(points_z))/2.) + np.min(points_z))
av_val = np.sum((out*points_z).reshape((self.bins[0], self.bins[1], 200)), axis=-1) / \
np.sum(out.reshape((self.bins[0], self.bins[1], 200)), axis=-1)
points_x = points_x.reshape((self.bins[0], self.bins[1], 200))[:, :, 0].ravel()
points_y = points_y.reshape((self.bins[0], self.bins[1], 200))[:, :, 0].ravel()
int_points = np.vstack((points_x, points_y)).T
lin = LinearNDInterpolator(np.vstack((points_x, points_y)).T, av_val.ravel(), fill_value=0)
return lin
elif training_library == "KNN":
from sklearn.neighbors import KNeighborsRegressor
model = KNeighborsRegressor(10)
model.fit(pixel_pos, amp)
elif training_library == "loess":
from loess.loess_2d import loess_2d
from scipy.interpolate import LinearNDInterpolator
sel = amp!=0
model = loess_2d(pixel_pos.T[0][sel], pixel_pos.T[1][sel], amp[sel],
degree=3, frac=0.005)
lin = LinearNDInterpolator(pixel_pos[sel], model[0])
return lin
elif training_library == "keras":
from keras.models import Sequential
from keras.layers import Dense
import keras
model = Sequential()
model.add(Dense(nodes[0], activation="relu", input_shape=(2,)))
for n in nodes[1:]:
model.add(Dense(n, activation="relu"))
model.add(Dense(1, activation='linear'))
model.compile(loss='mean_absolute_error',
optimizer="adam", metrics=['accuracy'])
stopping = keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=0.0,
patience=10,
verbose=2, mode='auto')
# pixel_pos_neg = np.array([pixel_pos.T[0], -1 * np.abs(pixel_pos.T[1])]).T
# pixel_pos = np.concatenate((pixel_pos, pixel_pos_neg))
# amp = np.concatenate((amp, amp))
model.fit(pixel_pos, amp, epochs=10000,
batch_size=100000,
callbacks=[stopping], validation_split=0.1, verbose=0)
return model
