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]
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 import matplotlib.pyplot as plt import pandas
class Autoencoder: def __init__(self, hidden_nodes, weights_init=None, weight_initializer='random_normal', biases_init=None, activation='sigmoid', batch_size=1, batch_norm=False, learning_rate=1e-3, momentum=0.9, regularization=0, optimizer='adam', max_epochs=sys.maxsize, convergence_criterion=(0, 10), backend='keras'): if backend not in ['tensorflow', 'keras', 'sklearn']: raise ValueError("invalid backend: {}".format(backend)) self._hidden_nodes = hidden_nodes self._weights_init = weights_init self._weight_initializer = weight_initializer self._biases_init = biases_init self._activation = activation self._batch_size = batch_size self._batch_norm = batch_norm self._learning_rate = learning_rate self._momentum = momentum self._regularization = regularization self._optimizer = optimizer self._max_epochs = max_epochs self._conv = convergence_criterion self._backend = backend @staticmethod def gridsearch(inputs, batch_sizes, learning_rates, regularizations, kwargs_model=None, cv=10, verbose=False): backend = kwargs_model.get('backend', 'keras') if backend != 'keras': err = "gridsearch currently only implemented for keras backend" raise ValueError(err) build_fn = AutoencoderFactoryKeras(inputs, kwargs_model) epochs = kwargs_model.get('max_epochs', sys.maxsize) estimator = KerasRegressor(build_fn=build_fn, epochs=epochs, verbose=0) search = GridSearchCV(estimator=estimator, scoring='neg_mean_absolute_error', cv=cv, param_grid={ 'bs': batch_sizes, 'lr': learning_rates, 'reg': regularizations }, return_train_score=True, error_score=np.nan, n_jobs=1, verbose=(51 if verbose else 0)) conv = kwargs_model.get('convergence_criterion', (0, 10)) callbacks = [ EarlyStopping(monitor='loss', min_delta=conv[0], patience=conv[1]) ] return search.fit(inputs, inputs, callbacks=callbacks) def train(self, inputs, inputs_val=None, epochs=None, learning_curve=False, verbose=False): kwargs = { 'inputs_val': inputs_val, 'epochs': epochs, 'learning_curve': learning_curve, 'verbose': verbose } if self._backend == 'tensorflow': self._init_model_tensorflow(inputs) return self._train_tensorflow(inputs, **kwargs) if self._backend == 'sklearn': self._init_model_sklearn(inputs) return self._train_sklearn(inputs, **kwargs) elif self._backend == 'keras': self._init_model_keras(inputs) return self._train_keras(inputs, **kwargs) def _init_model_tensorflow(self, inputs): if self._weights_init is not None or self._biases_init is not None: err = "custom weights currently not supported by tf backend" raise ValueError(err) def _train_tensorflow(self, inputs, inputs_val, epochs, learning_curve, verbose): if inputs_val is not None: err = "tf backend currently does not support validation" raise ValueError(err) if learning_curve and learning_curve != 'mse': err = "tf backend currently only supports MSE" raise ValueError(err) # process dataset dataset = tf.data.Dataset.from_tensor_slices(inputs) dataset = dataset.batch(self._batch_size) dataset = dataset.repeat() dataset = dataset.shuffle(10, inputs.shape[0]) dataset_it = dataset.make_one_shot_iterator() input_layer = dataset_it.get_next() # construct hidden and output layer layer_settings = {} layer_settings['activation'] = { 'sigmoid': tf.nn.sigmoid, 'relu': tf.nn.relu, 'elu': tf.nn.elu }[self._activation] layer_settings['kernel_initializer'] = { 'random_normal': tf.initializers.random_normal, 'xavier': tf.contrib.layers.xavier_initializer(uniform=False), 'he': tf.contrib.layers.variance_scaling_initializer() }[self._weight_initializer] if self._regularization > 0: layer_settings['kernel_regularizer'] = \ tf.contrib.layers.l2_regularizer(self._regularization) def layer(prev, nodes): print(layer_settings) # TODO res = tf.layers.dense(prev, nodes, **layer_settings) if self._batch_norm: res = tf.layers.batch_normalization(res, training=True, momentum=0.9) return res hidden_layer = layer(input_layer, self._hidden_nodes) output_layer = layer(hidden_layer, inputs.shape[1]) # set up otimization optimizer = { 'momentum': tf.train.MomentumOptimizer(self._learning_rate, self._momentum), 'momentum_nesterov': tf.train.MomentumOptimizer(self._learning_rate, self._momentum, use_nesterov=True), 'adam': tf.train.AdamOptimizer(self._learning_rate) }[self._optimizer] loss = tf.reduce_mean(tf.square(output_layer - input_layer)) training_op = optimizer.minimize(loss) # train model errors = [] batches = inputs.shape[0] // self._batch_size with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if epochs is None: err = "early stopping currently not supported by tf backend" raise ValueError(err) for e in range(epochs): for _ in range(batches): _, loss_ = sess.run([training_op, loss]) # determine current error errors.append(loss_) if verbose: self._show_progress(e, epochs) # return learning curve if learning_curve: epochs = list(range(1, len(errors) + 1)) return epochs, errors def _init_model_keras(self, inputs): # construct network def initializer(weights): def res(shape, dtype=None): assert shape == res.weights.shape if dtype is not None: weights = res.weights.astype(dtype) else: weights = res.weights return weights res.weights = weights return res if self._weights_init is not None: kernel_init_hidden = initializer(self._weights_init[0]) kernel_init_output = initializer(self._weights_init[1]) else: kernel_init_hidden = kernel_init_output = { 'random_normal': 'RandomNormal', 'xavier': 'glorot_normal', 'he': 'he_normal' }[self._weight_initializer] if self._biases_init is not None: bias_init_hidden = initializer(self._biases_init[0]) bias_init_output = initializer(self._biases_init[1]) else: bias_init_hidden = 'Zeros' bias_init_output = 'Zeros' hidden_layer = Dense( self._hidden_nodes, input_shape=(inputs.shape[1], ), activation=self._activation, kernel_initializer=kernel_init_hidden, bias_initializer=bias_init_hidden, kernel_regularizer=l2(self._regularization), ) output_layer = Dense(inputs.shape[1], activation=self._activation, kernel_initializer=kernel_init_output, bias_initializer=bias_init_output, kernel_regularizer=l2(self._regularization)) self._model = Sequential([hidden_layer, output_layer]) # set up optimization opt = { 'momentum': SGD(lr=self._learning_rate, momentum=self._momentum), 'momentum_nesterov': SGD(lr=self._learning_rate, momentum=self._momentum, nesterov=True), 'adam': Adam(lr=self._learning_rate) }[self._optimizer] self._model.compile(optimizer=opt, loss='mean_squared_error') def _train_keras(self, inputs, inputs_val, epochs, learning_curve, verbose): # compute initial errors if learning_curve: errors = [] if inputs_val is not None: errors_val = [] # define convergence criterion if epochs is None: callbacks = [ EarlyStopping(monitor='loss', min_delta=self._conv[0], patience=self._conv[1], verbose=(1 if verbose else 0)) ] epochs = self._max_epochs else: callbacks = [] # set up validation set if inputs_val is not None: validation_data = (inputs_val, inputs_val) else: validation_data = None # train model for e in range(epochs): h = self._model.fit(inputs, inputs, validation_data=validation_data, batch_size=self._batch_size, epochs=(e + 1), initial_epoch=e, callbacks=callbacks, verbose=0) # determine current error if learning_curve: if learning_curve == 'mse': errors.append(h.history['loss'][0]) if inputs_val is not None: errors_val.append(h.history['val_loss'][0]) elif learning_curve == 'total': errors.append(self.error(inputs)) if inputs_val is not None: errors_val.append(self.error(inputs_val)) # show progress if verbose: self._show_progress(e, epochs) # return learning curve if learning_curve: epochs = list(range(1, len(errors) + 1)) if inputs_val is not None: return epochs, errors, errors_val else: return epochs, errors def _init_model_sklearn(self, inputs): self._model = MLPRegressor( # structure hidden_layer_sizes=(self._hidden_nodes, ), # activation functions activation='logistic', # solver solver='sgd', warm_start=True, # batch size batch_size=self._batch_size, # learning rate learning_rate='constant', learning_rate_init=self._learning_rate, # momentum momentum=self._momentum, nesterovs_momentum=True, # regularization alpha=self._regularization, # convergence max_iter=self._max_epochs, tol=self._conv[0], n_iter_no_change=self._conv[1]) def _train_sklearn(self, inputs, inputs_val, epochs, learning_curve, verbose): if learning_curve and learning_curve != 'total': err = "sklearn backend currently only supports total error" raise ValueError(err) # initialize weights and biases if self._weights_init is None: self._weights_init = [ np.random.randn(inputs.shape[1], self._hidden_nodes), np.random.randn(self._hidden_nodes, inputs.shape[1]) ] if self._biases_init is None: self._biases_init = [ np.zeros(self._hidden_nodes), np.zeros(inputs.shape[1]) ] # initialize learning curve if learning_curve: total_errors = [] if inputs_val is not None: total_errors_val = [] best_total_error = math.inf dead_epochs = 0 epoch = 0 while True: if epoch == 0: # hack ahead, scikit learn's awful MLPRegressor interface # ordinarily does not allow manual weight initialization self._model.n_outputs_ = inputs.shape[1] self._model._random_state = check_random_state( self._model.random_state) self._model._initialize( inputs, [inputs.shape[1], self._hidden_nodes, inputs.shape[1]]) self._model.coefs_ = self._weights_init self._model.intercepts_ = self._biases_init continue else: self._model = self._model.partial_fit(inputs, inputs) # determine current error total_error = self.error(inputs) if learning_curve: total_errors.append(total_error) if inputs_val is not None: total_errors_val.append(self.error(inputs_val)) # show progress if verbose: self._show_progress(epoch, epochs) # check for convergence epoch += 1 if epochs is None: if total_error >= best_total_error - sel._conv[0]: dead_epochs += 1 if dead_epochs == self._conv[1]: break if total_error < best_total_error: best_total_error = min(best_total_error, total_error) dead_epochs = 0 else: if epoch > epochs: break # return learning curve if learning_curve: total_epochs = list(range(1, len(errors) + 1)) if inputs_val is not None: return total_epochs, total_errors, total_errors_val else: return total_epochs, total_errors def predict(self, i): return self._model.predict(i.reshape(1, len(i))) def error(self, inputs): total_error = 0 for i in inputs: pred = self.predict(i) total_error += np.mean(np.abs(pred - i)) return total_error @staticmethod def _show_progress(e, epochs): if epochs is None: print("\repoch {}".format(e)) else: bar = '=' * int(50 * (e + 1) / epochs) progress = "[{:<50}] epoch {}/{}".format(bar, e + 1, epochs) print("\r" + progress, end='')
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
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