def SparseDeconvolution(x, y, p, rtype='omp'):
from numpy import zeros, hstack, floor, array, shape, sign
from scipy.linalg import toeplitz, norm
from sklearn.linear_model import OrthogonalMatchingPursuit, Lasso
xm = x[abs(x).argmax()]
# x = (x.copy())/xm
x = (x.copy()) / xm
x = x / norm(x)
y = (y.copy()) / xm
Nx = len(x)
Ny = len(y)
X = toeplitz(hstack((x, zeros(Nx + Ny - 2))), r=zeros(Ny + Nx - 1))
Y = hstack((zeros(Nx - 1), y, zeros(Nx - 1)))
if (rtype == 'omp') & (type(p) == int):
model = OrthogonalMatchingPursuit(n_nonzero_coefs=p, normalize=True)
elif (rtype == 'omp') & (p < 1.0):
model = OrthogonalMatchingPursuit(tol=p, normalize=True)
elif (rtype == 'lasso'):
model = Lasso(alpha=p)
model.fit(X, Y)
h = model.coef_
b = model.intercept_
r = Y - b
r = r[int(len(x) / 2) - 1:int(len(x) / 2) - 1 + len(y)]
h = h[int(len(x) / 2) - 1:int(len(x) / 2) - 1 + len(y)]
return r, h
def omp_estimator(hparams): #pylint: disable=unused-argument
"""Orthogonal Matching Pursuit"""
omp_est = OrthogonalMatchingPursuit()
def estimator(A_val, y_val, hparams):
omp_est.fit(A_val.T, y_val.reshape(hparams.num_measurements))
x_hat = omp_est.coef_
x_hat = np.reshape(x_hat, (1, hparams.n_input))
x_hat = np.maximum(np.minimum(x_hat, 1), 0)
return x_hat
return estimator
def __init__(self,
name='image_',
image_feature_dict={},
reconsitution_element_nums=8,
error_limit=0.2):
self.name = name
self.image_feature_dict = image_feature_dict.copy()
self.reconsitution_element_nums = reconsitution_element_nums
self.error_limit = error_limit
self.omp = OrthogonalMatchingPursuit(
n_nonzero_coefs=reconsitution_element_nums)
def test_model_orthogonal_matching_pursuit(self):
model, X = fit_regression_model(OrthogonalMatchingPursuit())
model_onnx = convert_sklearn(
model, "orthogonal matching pursuit",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
verbose=False,
basename="SklearnOrthogonalMatchingPursuit-Dec4")
def get_hyperparameters_model():
param_dist = {}
clf = OrthogonalMatchingPursuit()
model = {
'orthogonal_matching_pursuit': {
'model': clf,
'param_distributions': param_dist
}
}
return model
def _estimate_X(self,Y,A):
if self.num_of_NZ is None:
n_nonzero_coefs = np.ceil(0.1 * A.shape[1])
else:
n_nonzero_coefs = self.num_of_NZ
omp = OrthogonalMatchingPursuit(n_nonzero_coefs = int(n_nonzero_coefs))
for j in range(A.shape[1]):
A[:,j] /= max(np.linalg.norm(A[:,j]),1e-20)
omp.fit(A,Y)
return omp.coef_.T
def test_omp_cv():
y_ = y[:, 0]
gamma_ = gamma[:, 0]
ompcv = OrthogonalMatchingPursuitCV(normalize=True, fit_intercept=False,
max_iter=10, cv=5)
ompcv.fit(X, y_)
assert_equal(ompcv.n_nonzero_coefs_, n_nonzero_coefs)
assert_array_almost_equal(ompcv.coef_, gamma_)
omp = OrthogonalMatchingPursuit(normalize=True, fit_intercept=False,
n_nonzero_coefs=ompcv.n_nonzero_coefs_)
omp.fit(X, y_)
assert_array_almost_equal(ompcv.coef_, omp.coef_)
def test_ransac_fit_sample_weight():
ransac_estimator = RANSACRegressor(random_state=0)
n_samples = y.shape[0]
weights = np.ones(n_samples)
ransac_estimator.fit(X, y, weights)
# sanity check
assert ransac_estimator.inlier_mask_.shape[0] == n_samples
ref_inlier_mask = np.ones_like(ransac_estimator.inlier_mask_).astype(
np.bool_)
ref_inlier_mask[outliers] = False
# check that mask is correct
assert_array_equal(ransac_estimator.inlier_mask_, ref_inlier_mask)
# check that fit(X) = fit([X1, X2, X3],sample_weight = [n1, n2, n3]) where
# X = X1 repeated n1 times, X2 repeated n2 times and so forth
random_state = check_random_state(0)
X_ = random_state.randint(0, 200, [10, 1])
y_ = np.ndarray.flatten(0.2 * X_ + 2)
sample_weight = random_state.randint(0, 10, 10)
outlier_X = random_state.randint(0, 1000, [1, 1])
outlier_weight = random_state.randint(0, 10, 1)
outlier_y = random_state.randint(-1000, 0, 1)
X_flat = np.append(
np.repeat(X_, sample_weight, axis=0),
np.repeat(outlier_X, outlier_weight, axis=0),
axis=0,
)
y_flat = np.ndarray.flatten(
np.append(
np.repeat(y_, sample_weight, axis=0),
np.repeat(outlier_y, outlier_weight, axis=0),
axis=0,
))
ransac_estimator.fit(X_flat, y_flat)
ref_coef_ = ransac_estimator.estimator_.coef_
sample_weight = np.append(sample_weight, outlier_weight)
X_ = np.append(X_, outlier_X, axis=0)
y_ = np.append(y_, outlier_y)
ransac_estimator.fit(X_, y_, sample_weight)
assert_allclose(ransac_estimator.estimator_.coef_, ref_coef_)
# check that if base_estimator.fit doesn't support
# sample_weight, raises error
base_estimator = OrthogonalMatchingPursuit()
ransac_estimator = RANSACRegressor(base_estimator, min_samples=10)
err_msg = f"{base_estimator.__class__.__name__} does not support sample_weight."
with pytest.raises(ValueError, match=err_msg):
ransac_estimator.fit(X, y, weights)
def test_multi_target_sample_weights_api():
X = [[1, 2, 3], [4, 5, 6]]
y = [[3.141, 2.718], [2.718, 3.141]]
w = [0.8, 0.6]
rgr = MultiOutputRegressor(OrthogonalMatchingPursuit())
assert_raises_regex(ValueError, "does not support sample weights", rgr.fit,
X, y, w)
# no exception should be raised if the base estimator supports weights
rgr = MultiOutputRegressor(GradientBoostingRegressor(random_state=0))
rgr.fit(X, y, w)
def test_omp_reaches_least_squares():
# Use small simple area_data; it's a sanity check but OMP can stop early
rng = check_random_state(0)
n_samples, n_features = (10, 8)
n_targets = 3
X = rng.randn(n_samples, n_features)
Y = rng.randn(n_samples, n_targets)
omp = OrthogonalMatchingPursuit(n_nonzero_coefs=n_features)
lstsq = LinearRegression()
omp.fit(X, Y)
lstsq.fit(X, Y)
assert_array_almost_equal(omp.coef_, lstsq.coef_)
def orthogonal_matching_pursuit():
n_components, n_features = 512, 100
n_nonzero_coefs = 17
# generate the data
# y = Xw
# |x|_0 = n_nonzero_coefs
y, X, w = make_sparse_coded_signal(n_samples=1,
n_components=n_components,
n_features=n_features,
n_nonzero_coefs=n_nonzero_coefs,
random_state=0)
idx, = w.nonzero()
# distort the clean signal
y_noisy = y + 0.05 * np.random.randn(len(y))
# # plot the sparse signal
# plt.figure(figsize=(7, 7))
# plt.subplot(4, 1, 1)
# plt.xlim(0, 512)
# plt.title("Sparse signal")
# plt.stem(idx, w[idx], use_line_collection=True)
# plot the noise-free reconstruction
omp = OrthogonalMatchingPursuit(n_nonzero_coefs=n_nonzero_coefs)
omp.fit(X, y)
coef = omp.coef_
idx_r, = coef.nonzero()
# plt.subplot(4, 1, 2)
# plt.xlim(0, 512)
# plt.title("Recovered signal from noise-free measurements")
# plt.stem(idx_r, coef[idx_r], use_line_collection=True)
# plot the noisy reconstruction
omp.fit(X, y_noisy)
coef = omp.coef_
idx_r, = coef.nonzero()
# plt.subplot(4, 1, 3)
# plt.xlim(0, 512)
# plt.title("Recovered signal from noisy measurements")
# plt.stem(idx_r, coef[idx_r], use_line_collection=True)
# plot the noisy reconstruction with number of non-zeros set by CV
omp_cv = OrthogonalMatchingPursuitCV()
omp_cv.fit(X, y_noisy)
coef = omp_cv.coef_
idx_r, = coef.nonzero()
def __init__(self,
n_components=49,
patch_size=(8, 8),
max_samples=1000000,
**kwargs):
self.omp = OrthogonalMatchingPursuit()
self.n_components = n_components
self.patch_size = patch_size
self.max_samples = max_samples
self.D = None
self.data = None
self.components = None
self.standardize = False
def constrained_binary_solve(
w, psi, fit_intercept=True, normalize=True, precompute="auto"
):
if ndim(w) != 1:
raise ValueError(
f"w must be a 1D vector; received a vector of dimension {ndim(w)}"
)
model = OrthogonalMatchingPursuit(
tol=0, fit_intercept=fit_intercept, normalize=normalize, precompute=precompute
)
model.fit(psi, w)
return model.coef_
def csper(t,y,fmin=None,fmax=None,nfreqs=5000,nsines=4,polyorder=2,sig=5):
trange = np.nanmax(t)-np.nanmin(t)
dt = np.abs(np.nanmedian(t-np.roll(t,-1)))
nt = np.size(t)
# make defaults
if fmin is None:
fmin = 1./trange
if fmax is None:
fmax = 2./dt
freqs = np.linspace(fmin,fmax,nfreqs)
df = np.abs(np.nanmedian(freqs-np.roll(freqs,-1)))
X = np.zeros((nt,nfreqs*2+polyorder))
# set up matrix of sines and cosines
for j in range(nfreqs):
X[:,j] = np.sin(t*freqs[j])
X[:,nfreqs+j] = np.cos(t*freqs[j])
# now do polynomial bits
for j in range(polyorder):
X[:,-j] = t**(polyorder-j)
n_components, n_features = nfreqs, nt
n_nonzero_coefs = nsines+polyorder
omp = OrthogonalMatchingPursuit(n_nonzero_coefs=n_nonzero_coefs)
omp.fit(X, y-np.nanmedian(y))
coef = omp.coef_
idx_r, = coef[:-polyorder].nonzero()
sines = freqs[idx_r[idx_r<nfreqs]]
cosines = freqs[idx_r[idx_r>nfreqs]-nfreqs]
print('Sine components:', sines)
print('Cosine components:',cosines)
amp_raw = np.sqrt(coef[:nfreqs]**2. + coef[nfreqs:-polyorder]**2)
amp = gaussian_filter1d(amp_raw,sig)
recon = np.dot(X,coef)
output = {'Frequencies':freqs,
'Raw_Amplitudes':coef[:-polyorder],
'Polynomial':coef[-polyorder:],
'Reconstruction':recon,
'Amplitude':amp}
return output
def solve_preconditioned_orthogonal_matching_pursuit(basis_matrix_func,
samples,values,
precond_func,
tol=1e-8):
from sklearn.linear_model import OrthogonalMatchingPursuit
basis_matrix = basis_matrix_func(samples)
weights = precond_func(basis_matrix,samples)
basis_matrix = basis_matrix*weights[:,np.newaxis]
rhs = values*weights[:,np.newaxis]
omp = OrthogonalMatchingPursuit(tol=tol,fit_intercept=False)
omp.fit(basis_matrix, rhs)
coef = omp.coef_
print('nnz_terms',np.count_nonzero(coef))
return coef[:,np.newaxis]
def cross_OMP(D1,D2,Y1,Y2):
'''
Input:
D1: Dictionary of Train [256 * n_components]
D2: Dictionary of Clapping [256*components]
Y1: Data matrix of SINGLE sample of Train [256*n]
Y2: Data matrix of SINGLE sample of Train [256*n]
Output:
X1, X2: Concatenated feature vectors [2 * n_components * n]
** n = 861 **
'''
# X11
omp11 = OrthogonalMatchingPursuit(n_nonzero_coefs=5)
omp11.fit(D1,Y1)
X11 = omp11.coef_
# X12
omp12 = OrthogonalMatchingPursuit(n_nonzero_coefs=5)
omp12.fit(D1,Y2)
X12 = omp12.coef_
# X21
omp21 = OrthogonalMatchingPursuit(n_nonzero_coefs=5)
omp21.fit(D2,Y1)
X21 = omp21.coef_
# X22
omp22 = OrthogonalMatchingPursuit(n_nonzero_coefs=5)
omp22.fit(D2,Y2)
X22 = omp22.coef_
# concatenate
X1 = np.hstack((X11,X12))
# print(X1.shape)
X1 = np.max(X1,axis = 0)
# print(X1.shape)
X2 = np.hstack((X21,X22))
X2 = np.max(X2,axis = 0)
return X1, X2
def omp_estimator(hparams):
"""OMP estimator"""
omp_est = OrthogonalMatchingPursuit(n_nonzero_coefs=hparams.omp_k)
def estimator(A_val, y_batch_val, hparams):
x_hat_batch = []
for i in range(hparams.batch_size):
y_val = y_batch_val[i]
omp_est.fit(A_val.T, y_val.reshape(hparams.num_measurements))
x_hat = omp_est.coef_
x_hat = np.reshape(x_hat, [-1])
x_hat = np.maximum(np.minimum(x_hat, 1), 0)
x_hat_batch.append(x_hat)
x_hat_batch = np.asarray(x_hat_batch)
return x_hat_batch
return estimator
def _orthogonal_matching_pursuit(response_mat: pd.DataFrame, diff_vec,
opt: DotDict):
""" Calculated n_correctors via orthogonal matching pursuit"""
if opt.n_correctors is None:
raise ValueError(
"n_correctors setting needed for orthogonal matching pursuit.")
res = OrthogonalMatchingPursuit(opt.n_correctors).fit(
response_mat, diff_vec)
coef = res.coef_
LOG.debug(
f"Orthogonal Matching Pursuit Results: \n"
f" Chosen variables: {response_mat.columns.to_numpy()[coef.nonzero()]}\n"
f" Score: {res.score(response_mat, diff_vec)}")
return coef
def test_scaling_with_gram():
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
# Use only 1 nonzero coef to be faster and to avoid warnings
omp1 = OrthogonalMatchingPursuit(n_nonzero_coefs=1,
fit_intercept=False,
normalize=False)
omp2 = OrthogonalMatchingPursuit(n_nonzero_coefs=1,
fit_intercept=True,
normalize=False)
omp3 = OrthogonalMatchingPursuit(n_nonzero_coefs=1,
fit_intercept=False,
normalize=True)
omp1.fit(X, y, Gram=G)
omp1.fit(X, y, Gram=G, Xy=Xy)
assert_true(len(w) == 3)
omp2.fit(X, y, Gram=G)
assert_true(len(w) == 5)
omp2.fit(X, y, Gram=G, Xy=Xy)
assert_true(len(w) == 8)
omp3.fit(X, y, Gram=G)
assert_true(len(w) == 10)
omp3.fit(X, y, Gram=G, Xy=Xy)
assert_true(len(w) == 13)
def get_regressor(self): if self.regr_type == "lr": self.regr = LinearRegression() elif self.regr_type == "ridge": self.regr = Ridge() elif self.regr_type == "omp": self.regr = OrthogonalMatchingPursuit() elif self.regr_type == "brr": self.regr = BayesianRidge() elif self.regr_type == "lsvr": self.regr = LinearSVR() elif self.regr_type == "svr": self.regr = SVR() elif self.regr_type == "rf": self.regr = RandomForestRegressor()
def __init__(self, models_parameters, base_forest_estimator):
if models_parameters.extraction_strategy == 'omp_nn':
self._omp = NonNegativeOrthogonalMatchingPursuit(
max_iter=models_parameters.extracted_forest_size,
intermediate_solutions_sizes=models_parameters.
intermediate_solutions_sizes,
fill_with_final_solution=True)
else:
# fit_intercept shouldn't be set to False as the data isn't necessarily centered here
# normalization is handled outsite OMP
self._omp = OrthogonalMatchingPursuit(
n_nonzero_coefs=models_parameters.extracted_forest_size,
fit_intercept=True,
normalize=False)
super().__init__(models_parameters, base_forest_estimator)
def _orthogonal_matching_pursuit(response_mat, diff_vec, opt):
""" Calculated n_correctors via orthogonal matching pursuit"""
if opt.n_correctors is None:
raise ValueError(
"n_correctors setting needed for orthogonal matching pursuit.")
# return orthogonal_mp(response_mat, diff_vec, opt.n_correctors)
res = OrthogonalMatchingPursuit(opt.n_correctors).fit(
response_mat, diff_vec)
coef = res.coef_
LOG.debug("Orthogonal Matching Pursuit Results:")
LOG.debug(" Chosen variables: {:s}".format(
str(response_mat.columns.values[coef.nonzero()])))
LOG.debug(" Score: {:f}".format(res.score(response_mat, diff_vec)))
return coef
def test_OMP():
"""
find the 3 best nodes in the set [0, 0.1, ..., 0.9, 1.0] and their weights using Orthogonal Matching Pursuit
"""
kernel = Matern(length_scale=0.8, nu=1.2)
set_size = 100
x = []
y = []
for n in range(set_size):
f = GPRealization(kernel)
data = []
for num in np.linspace(0, 1, 11):
data.append(f(num))
x.append(data)
y.append(quad(f, 0, 1)[0])
# build OMP model
reg = OrthogonalMatchingPursuit(3).fit(x, y)
print(reg.coef_)
print(reg.intercept_)
# test against simpsons rule
num_tests = 100
reg_better = 0
total_err_simps = 0.0
total_err_reg = 0.0
for i in range(num_tests):
f = GPRealization(kernel)
data = []
for num in np.linspace(0, 1, 11):
data.append(f(num))
int_reg = reg.predict([data])
int_reg = int_reg[0]
int_simpsons = 1 / 6 * f(0) + 4 / 6 * f(.5) + 1 / 6 * f(1)
int_true = quad(f, 0, 1)[0]
total_err_simps += abs(int_simpsons - int_true)
total_err_reg += abs(int_reg - int_true)
if abs(int_reg - int_true) < abs(int_simpsons - int_true):
reg_better += 1
print("The Regression Model was better in {} of {} cases".format(
reg_better, num_tests))
print("The average error of the Regression model was {}".format(
total_err_reg / num_tests))
print("The average error of the simpsons rule was {}".format(
total_err_simps / num_tests))
def solve_preconditioned_orthogonal_matching_pursuit(basis_matrix_func,
samples,
values,
precond_func,
tol=1e-8):
basis_matrix = basis_matrix_func(samples)
weights = precond_func(basis_matrix, samples)
basis_matrix = basis_matrix * weights[:, np.newaxis]
rhs = values * weights[:, np.newaxis]
if basis_matrix.shape[1] == 1 or tol > 0:
omp = OrthogonalMatchingPursuit(tol=tol)
else:
omp = OrthogonalMatchingPursuitCV(cv=min(samples.shape[1], 10))
res = omp.fit(basis_matrix, rhs)
coef = omp.coef_
coef[0] += res.intercept_
return coef[:, np.newaxis]
def test_omp_cv():
# FIXME: This test is unstable on Travis, see issue #3190 for more detail.
check_skip_travis()
y_ = y[:, 0]
gamma_ = gamma[:, 0]
ompcv = OrthogonalMatchingPursuitCV(normalize=True,
fit_intercept=False,
max_iter=10,
cv=5)
ompcv.fit(X, y_)
assert_equal(ompcv.n_nonzero_coefs_, n_nonzero_coefs)
assert_array_almost_equal(ompcv.coef_, gamma_)
omp = OrthogonalMatchingPursuit(normalize=True,
fit_intercept=False,
n_nonzero_coefs=ompcv.n_nonzero_coefs_)
omp.fit(X, y_)
assert_array_almost_equal(ompcv.coef_, omp.coef_)
def get_model_from_name(model_name):
model_map = {
# Classifiers
'LogisticRegression': LogisticRegression(n_jobs=-2),
'RandomForestClassifier': RandomForestClassifier(n_jobs=-2),
'RidgeClassifier': RidgeClassifier(),
'GradientBoostingClassifier': GradientBoostingClassifier(),
'ExtraTreesClassifier': ExtraTreesClassifier(n_jobs=-1),
'AdaBoostClassifier': AdaBoostClassifier(n_estimators=10),
'SGDClassifier': SGDClassifier(n_jobs=-1),
'Perceptron': Perceptron(n_jobs=-1),
'PassiveAggressiveClassifier': PassiveAggressiveClassifier(),
# Regressors
# 'DeepLearningRegressor': KerasRegressor(build_fn=make_deep_learning_model, nb_epoch=10, batch_size=10, verbose=1),
'LinearRegression': LinearRegression(n_jobs=-2),
'RandomForestRegressor': RandomForestRegressor(n_jobs=-2),
'Ridge': Ridge(),
'ExtraTreesRegressor': ExtraTreesRegressor(n_jobs=-1),
'AdaBoostRegressor': AdaBoostRegressor(n_estimators=10),
'RANSACRegressor': RANSACRegressor(),
'GradientBoostingRegressor': GradientBoostingRegressor(presort=False),
'Lasso': Lasso(),
'ElasticNet': ElasticNet(),
'LassoLars': LassoLars(),
'OrthogonalMatchingPursuit': OrthogonalMatchingPursuit(),
'BayesianRidge': BayesianRidge(),
'ARDRegression': ARDRegression(),
'SGDRegressor': SGDRegressor(shuffle=False),
'PassiveAggressiveRegressor':
PassiveAggressiveRegressor(shuffle=False),
# Clustering
'MiniBatchKMeans': MiniBatchKMeans(n_clusters=8)
}
if xgb_installed:
model_map['XGBClassifier'] = xgb.XGBClassifier(colsample_bytree=0.8,
min_child_weight=5,
subsample=1.0,
learning_rate=0.1,
n_estimators=200,
nthread=-1)
model_map['XGBRegressor'] = xgb.XGBRegressor(nthread=-1,
n_estimators=200)
return model_map[model_name]
def __init__(self,
model_feats,
neural_feats_reps,
labels,
regression=OrthogonalMatchingPursuit(),
n_splits=10,
test_size=1 / 4.,
n_splithalves=10,
pca=False,
n_components=None,
**parallel_kwargs):
"""
Regression of model features to neurons.
:Args:
- model_feats
Model responses corresponding to stimuli in dataset
- neural_feats_reps
Neural responses in the format of (reps, images, sites)
:Kwargs:
- n_splits
Number of splits into (train, test)
- n_splithalves
Number of splits over reps
:Returns:
The fit outcome (pandas.DataFrame)
"""
self.model_feats = model_feats
self._neural_feats_reps = neural_feats_reps
self.labels = labels
self.reg = regression
self.n_splits = n_splits
self.n_splithalves = n_splithalves
self.do_pca = bool(pca)
self._pca = pca
self.n_components = n_components
self.pkwargs = parallel_kwargs
self.rng = np.random.RandomState(0)
sss = StratifiedShuffleSplit(n_splits=self.n_splits,
test_size=test_size,
random_state=self.rng)
self.splits = [s for s in sss.split(self.model_feats, self.labels)]
def __default_regressors():
return {
'huber': HuberRegressor(),
'theil_sen': TheilSenRegressor(),
'linear': LinearRegression(),
'ard': ARDRegression(),
'orthogonal_matching': OrthogonalMatchingPursuit(),
'elastic_net': ElasticNet(),
'bayesian_ridge': BayesianRidge(),
'lasso_lars': LassoLars(),
'lasso': Lasso(),
'ridge': Ridge(),
'gaussian_process': GaussianProcessRegressor(),
'decision_tree': DecisionTreeRegressor(),
'svr': SVR(),
'nu_svr': NuSVR(),
'kernel_ridge': KernelRidge()
}
def fit_predict_omp(self, X, y=None):
n_sample = X.transpose().shape[0]
H = X.transpose(
) #NRP_ELM(self.n_hidden, sparse=False).fit(X).predict(X)
C = np.zeros((n_sample, n_sample))
# solve sparse self-expressive representation
for i in range(n_sample):
y_i = H[i]
H_i = np.delete(H, i, axis=0)
# H_T = H_i.transpose() # M x (N-1)
omp = OrthogonalMatchingPursuit(n_nonzero_coefs=int(n_sample *
0.5),
tol=1e20)
omp.fit(H_i.transpose(), y_i)
# Normalize the columns of C: ci = ci / ||ci||_ss.
coef = omp.coef_ / np.max(np.abs(omp.coef_))
C[:i, i] = coef[:i]
C[i + 1:, i] = coef[i:]
# # compute affinity matrix
# L = 0.5 * (np.abs(C) + np.abs(C.T)) # affinity graph
# # L = 0.5 * (C + C.T)
# self.affinity_matrix = L
# # spectral clustering
# sc = SpectralClustering(n_clusters=self.n_clusters, affinity='precomputed')
# sc.fit(self.affinity_matrix)
# K-means clustering
kmeans = KMeans(n_clusters=self.n_clusters, max_iter=500).fit(C)
label = kmeans.labels_
C_ = C
band_index = []
for i in np.unique(label):
index__ = np.nonzero(label == i)
centroids_ = C_[index__]
centroids = centroids_.mean(axis=0)
dis = pairwise_distances(
centroids_, centroids.reshape(
(1, centroids_.shape[1]))).flatten()
index_min = np.argmin(dis)
C_bestrow = centroids_[index_min, :]
index = np.nonzero(np.all(C_ == C_bestrow, axis=1))
band_index.append(index[0][0])
BandData = X[:, band_index] # BandData = self.X[:, band_index]
print('selected band:', band_index)
return BandData #sc.labels_
def update(self, x, t):
"""
Updates skill success conditions.
:param x: input
:param t: target (bool)
:return: None
"""
# Don't add duplicates
for i in range(len(self.all_x)):
if self.all_t[i] == t and np.all(self.all_x[i] == x):
return
# Update skill dataset
self.all_x.append(x)
self.all_t.append(t)
# Can't learn from too few elements
n_x = len(self.all_x)
n_unique_t = np.unique(self.all_t).shape[0]
if n_x <= 2 or n_unique_t < 2:
return
# apply OMP
all_x = np.array(self.all_x)
all_t = np.array(self.all_t).reshape(-1, 1)
omp = OrthogonalMatchingPursuit(tol=self.omp_tol)
omp.fit(all_x, all_t)
# Trim data
self.used_dims, = omp.coef_.nonzero()
x_trim = all_x[:, self.used_dims]
x_true = x_trim[np.where(all_t)[0], :]
if x_true.shape[0] >= 2 and x_true.shape[1] > 0:
# train GMM
self.gmm = GaussianMixture(
n_components=min(len(self.used_dims), self.n_gmm_components))
# Add a bit of noise to avoid duplicate points
x_noisy = x_true + 0.01 * np.random.normal(size=x_true.shape)
self.gmm.fit(x_noisy)
self.fitted = True
self.gmm_samples_dim, self.gmm_samples_values = \
self.__generate_gmm_samples(20)
