class GaussianProcessRegressorImpl():
def __init__(self,
kernel=None,
alpha=1e-10,
optimizer='fmin_l_bfgs_b',
n_restarts_optimizer=0,
normalize_y=False,
copy_X_train=True,
random_state=None):
self._hyperparams = {
'kernel': kernel,
'alpha': alpha,
'optimizer': optimizer,
'n_restarts_optimizer': n_restarts_optimizer,
'normalize_y': normalize_y,
'copy_X_train': copy_X_train,
'random_state': random_state
}
self._wrapped_model = SKLModel(**self._hyperparams)
def fit(self, X, y=None):
if (y is not None):
self._wrapped_model.fit(X, y)
else:
self._wrapped_model.fit(X)
return self
def predict(self, X):
return self._wrapped_model.predict(X)
def _fit_gp(X, y, kernel, max_gp):
n_samples = X.shape[0]
n_gp = min(n_samples, max_gp)
X = X[(n_samples - n_gp):n_samples, :]
y = y[(n_samples - n_gp):n_samples]
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp.fit(X, y)
return gp
def fit(self, X, y=None):
self._sklearn_model = SKLModel(**self._hyperparams)
if (y is not None):
self._sklearn_model.fit(X, y)
else:
self._sklearn_model.fit(X)
return self
def fit(kernel, sample_indices, X, y, n_restarts_optimizer, normalize_y):
"""Fits a Gaussian Process Regression model on a subset of X and y using
the provided covariance kernel and subset indices. This is used as a single
worker payload in the parallel fitting process of the rBCM.
TODO: take the sample_indices argument out of this function and keep it
in the logic of the rBCM class alone. Just pass the X and y we'll
actually use. For now keep it to avoid too many changes during the
refactor, however.
Args:
kernel : sklearn kernel object
The kernel specifying the covariance function of the Guassian
Process.
sample_indices : list of integers
The indices of the subset of X and y to fit
X : np.ndarray
The locations of the points.
Must match y in length.
y : np.ndarray
The values of the points at the X locations.
Must match X in length.
n_restarts_optimizer : non-negative integer
The number of restarts to permit in the GPR. Look to scikit-learn's
GPR implementation for more detail as it is passed through.
normalize_y : boolean
Whether to normalize the scale of y to improve fitting quality.
See scikit-learn's GPR implementation for more detail.
"""
gpr = GPR(kernel,
n_restarts_optimizer=n_restarts_optimizer,
copy_X_train=False,
normalize_y=normalize_y)
gpr.fit(X[sample_indices, :], y[sample_indices, :])
return gpr
def fit(kernel, sample_indices, X, y, n_restarts_optimizer, normalize_y):
"""Fits a Gaussian Process Regression model on a subset of X and y using
the provided covariance kernel and subset indices. This is used as a single
worker payload in the parallel fitting process of the rBCM.
TODO: take the sample_indices argument out of this function and keep it
in the logic of the rBCM class alone. Just pass the X and y we'll
actually use. For now keep it to avoid too many changes during the
refactor, however.
Args:
kernel : sklearn kernel object
The kernel specifying the covariance function of the Guassian
Process.
sample_indices : list of integers
The indices of the subset of X and y to fit
X : np.ndarray
The locations of the points.
Must match y in length.
y : np.ndarray
The values of the points at the X locations.
Must match X in length.
n_restarts_optimizer : non-negative integer
The number of restarts to permit in the GPR. Look to scikit-learn's
GPR implementation for more detail as it is passed through.
normalize_y : boolean
Whether to normalize the scale of y to improve fitting quality.
See scikit-learn's GPR implementation for more detail.
"""
gpr = GPR(kernel, n_restarts_optimizer=n_restarts_optimizer,
copy_X_train=False, normalize_y=normalize_y)
gpr.fit(X[sample_indices, :], y[sample_indices, :])
return gpr
def fix_patch(c, w, h, patch_size, corr_img, recover_img):
width = recover_img.shape[1]
height = recover_img.shape[2]
g = GaussianProcessRegressor(kernel=RBF(patch_size))
if w + patch_size >= width:
w = patch_size - width - 1
if h + patch_size >= height:
h = patch_size - height
channel_img = corr_img[c, w:w + patch_size, h:h + patch_size]
noise_mask = channel_img == 0
sample_coordinates = np.nonzero(~noise_mask)
if len(sample_coordinates[0]) == 0:
return fix_patch(c, w, h, patch_size * 2, corr_img, recover_img)
# if len(sample_coordinates[0]) < 2 * patch_size:
# return fix_patch(c, w, h, patch_size * 2, recover_img)
train_x = np.array(sample_coordinates).transpose()
train_y = channel_img[sample_coordinates]
g.fit(train_x, train_y)
predict_coordinates = np.nonzero(noise_mask)
predict_x = np.array(predict_coordinates).transpose()
predict_y = g.predict(predict_x)
recover_img[c, w:w + patch_size,
h:h + patch_size][predict_coordinates] = predict_y
def __init__(self,
kernel=None,
alpha=1e-10,
optimizer='fmin_l_bfgs_b',
n_restarts_optimizer=0,
normalize_y=False,
copy_X_train=True,
random_state=None):
self._hyperparams = {
'kernel': kernel,
'alpha': alpha,
'optimizer': optimizer,
'n_restarts_optimizer': n_restarts_optimizer,
'normalize_y': normalize_y,
'copy_X_train': copy_X_train,
'random_state': random_state
}
self._wrapped_model = SKLModel(**self._hyperparams)
"K-Neighbors",
"Radius Neighbors",
"MLP",
"Decision Tree",
"Extra Tree",
"SVR"
]
classifiers = [
RandomForestRegressor(n_estimators=200, n_jobs=5,
random_state=randomstate),
ExtraTreesRegressor(n_estimators=200, n_jobs=5, random_state=randomstate),
# GradientBoostingRegressor(random_state=randomstate), # learning_rate is a hyper-parameter in the range (0.0, 1.0]
# HistGradientBoostingClassifier(random_state=randomstate), # learning_rate is a hyper-parameter in the range (0.0, 1.0]
AdaBoostRegressor(n_estimators=200, random_state=randomstate),
GaussianProcessRegressor(normalize_y=True),
ARDRegression(),
# HuberRegressor(), # epsilon: greater than 1.0, default 1.35
LinearRegression(n_jobs=5),
PassiveAggressiveRegressor(
random_state=randomstate), # C: 0.25, 0.5, 1, 5, 10
SGDRegressor(random_state=randomstate),
TheilSenRegressor(n_jobs=5, random_state=randomstate),
RANSACRegressor(random_state=randomstate),
KNeighborsRegressor(
weights='distance'), # n_neighbors: 3, 6, 9, 12, 15, 20
RadiusNeighborsRegressor(weights='distance'), # radius: 1, 2, 5, 10, 15
MLPRegressor(max_iter=10000000, random_state=randomstate),
DecisionTreeRegressor(
random_state=randomstate), # max_depth = 2, 3, 4, 6, 8
ExtraTreeRegressor(random_state=randomstate), # max_depth = 2, 3, 4, 6, 8
'ElasticNetCV':ElasticNetCV(), 'EmpiricalCovariance':EmpiricalCovariance(), 'ExtraTreeClassifier':ExtraTreeClassifier(), 'ExtraTreeRegressor':ExtraTreeRegressor(), 'ExtraTreesClassifier':ExtraTreesClassifier(), 'ExtraTreesRegressor':ExtraTreesRegressor(), 'FactorAnalysis':FactorAnalysis(), 'FastICA':FastICA(), 'FeatureAgglomeration':FeatureAgglomeration(), 'FunctionTransformer':FunctionTransformer(), 'GMM':GMM(), 'GaussianMixture':GaussianMixture(), 'GaussianNB':GaussianNB(), 'GaussianProcess':GaussianProcess(), 'GaussianProcessClassifier':GaussianProcessClassifier(), 'GaussianProcessRegressor':GaussianProcessRegressor(), 'GaussianRandomProjection':GaussianRandomProjection(), 'GenericUnivariateSelect':GenericUnivariateSelect(), 'GradientBoostingClassifier':GradientBoostingClassifier(), 'GradientBoostingRegressor':GradientBoostingRegressor(), 'GraphLasso':GraphLasso(), 'GraphLassoCV':GraphLassoCV(), 'HuberRegressor':HuberRegressor(), 'Imputer':Imputer(), 'IncrementalPCA':IncrementalPCA(), 'IsolationForest':IsolationForest(), 'Isomap':Isomap(), 'KMeans':KMeans(), 'KNeighborsClassifier':KNeighborsClassifier(), 'KNeighborsRegressor':KNeighborsRegressor(), 'KernelCenterer':KernelCenterer(),
if __name__ == '__main__':
# initial parameters
# sklearn will adjust these parameters based on data
# see gpr.kernel_
length = 1.5
period = 2 * np.pi
noise_level = .6
# define problem
x, y = generate_data() # available data
finex = np.linspace(min(x), max(x), 77) # prediction locations
# krige
# step 1: define correlation function
kernel = ExpSineSquared(length_scale=length, periodicity=period) +\
WhiteKernel(noise_level)
# step 2: incorporate available data
gpr = GaussianProcessRegressor(kernel=kernel)
gpr.fit(x[:, None], y)
print(gpr.kernel_)
# step 3: make predictions
fineym, fineye = gpr.predict(finex[:, None], return_std=True)
# show results
fig, ax = plt.subplots(1, 1)
ax.set_xlabel('x')
ax.set_ylabel('y')
show_data(ax, x, y, finex, myfunc)
show_krig(ax, finex, fineym, fineye)
ax.legend()
plt.show()
# end __main__
test_size=0.2,
random_state=np.random.randint(1, 1000))
# Separate output from inputs
y_train = train_set['time_to_failure']
x_train_seg = train_set['segment_id']
x_train = train_set.drop(['time_to_failure', 'segment_id'], axis=1)
y_test = test_set['time_to_failure']
x_test_seg = test_set['segment_id']
x_test = test_set.drop(['time_to_failure', 'segment_id'], axis=1)
# y_train = np.around(y_train.values, decimals=2)
# mlpReg = MLPRegressor(verbose=True, tol=0.0001, max_iter=200000, n_iter_no_change=10000, hidden_layer_sizes=(200,))
# Instantiate a Gaussian Process model
kernel = C(1.0, (1e-3, 1e3)) * RBF(10, (1e-2, 1e2))
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=9)
gp.fit(x_train, y_train)
# Create an variable to pickle and open it in write mode
mh = ModelHolder(gp, most_dependent_columns)
mh.save(model_name)
gp = None
mh_new = load_model(model_name)
gp, most_dependent_columns = mh_new.get()
y_pred = gp.predict(x_test)
# y_pred = pd.Series(y_pred).apply(lambda x: float(x / 10))
print('MAE for Multi Layer Perceptron', mean_absolute_error(y_test, y_pred))