def _impose_f_order(X):
"""Helper Function"""
# important to access flags instead of calling np.isfortran,
# this catches corner cases.
if X.flags.c_contiguous:
return array2d(X.T, copy=False, order='F'), True
else:
return array2d(X, copy=False, order='F'), False
def fit(self, inp, y, sample_weight=None):
self.classes_, y = numpy.unique(y, return_inverse=True)
self.n_classes_ = len(self.classes_)
if self.training_params is None:
training_params = {}
else:
training_params = self.training_params
y = OneHotEncoder().fit_transform(array2d(y).transpose()).toarray()
n_features = inp.shape[1]
random_state = check_random_state(self.random_state)
if self.hidden_neurons == "a":
hidden_neurons = (n_features + self.n_classes_)/2
else:
hidden_neurons = self.hidden_neurons
if self.independent_outputs:
graph = imlgraph(
(n_features, hidden_neurons, self.n_classes_), biases=self.bias
)
else:
graph = mlgraph(
(n_features, hidden_neurons, self.n_classes_), biases=self.bias
)
self.network_ = ffnet(graph, random_state)
self.network_.randomweights()
trainer = getattr(self.network_, "train_" + self.training_fn)
trainer(inp, y, **training_params)
return self
def evd_transform(X, components, ncomps=-1):
X = validation.array2d(X)
if ncomps == -1:
X_transformed = np.dot(X, components)
# X_transformed = np.dot(components.T, X.T)
else:
X_transformed = np.dot(X, components[0:ncomps])
return X_transformed
def predict_proba(self, inp):
inp = array2d(inp)
probs = numpy.zeros((len(inp), self.n_classes_))
for i, x in enumerate(inp):
p = self.activate(x)
if p.min() < 0:
p = p - p.min()
if p.sum() > 0:
p = p / p.sum()
probs[i] = p
preprocessing.normalize(probs, norm="l1", copy=False)
return probs
def transform(self, X, y=None):
"""Encode the data as a sparse combination of the dictionary atoms.
Coding method is determined by the object parameter
`transform_algorithm`.
Parameters
----------
X : array of shape (n_samples, n_features)
Test data to be transformed, must have the same number of
features as the data used to train the model.
Returns
-------
X_new : array, shape (n_samples, n_components)
Transformed data
"""
# XXX : kwargs is not documented
X = array2d(X)
n_samples, n_features = X.shape
code = sparse_encode(
X, self.components_, algorithm=self.transform_algorithm,
n_nonzero_coefs=self.transform_n_nonzero_coefs,
alpha=self.transform_alpha, n_jobs=self.n_jobs)
if self.split_sign:
# feature vector is split into a positive and negative side
n_samples, n_features = code.shape
split_code = np.empty((n_samples, 2 * n_features))
split_code[:, :n_features] = np.maximum(code, 0)
split_code[:, n_features:] = -np.minimum(code, 0)
code = split_code
return code
def staged_decision_function(self, X):
X = array2d(X, dtype=DTYPE)
result = numpy.zeros(len(X))
for rate, classifier in zip(self.learning_rates, self.classifiers):
result += rate * classifier.predict(X)
yield result
def decision_function(self, X):
X = array2d(X, dtype=DTYPE)
result = numpy.zeros(len(X))
for rate, estimator in zip(self.learning_rates, self.classifiers):
result += rate * estimator.predict(X)
return result
def staged_decision_function(self, X):
X = array2d(X, dtype=DTYPE)
result = numpy.zeros(len(X))
for rate, classifier in zip(self.learning_rates, self.classifiers):
result += rate * classifier.predict(X)
yield result
def decision_function(self, X):
X = array2d(X, dtype=DTYPE)
result = numpy.zeros(len(X))
for rate, estimator in zip(self.learning_rates, self.classifiers):
result += rate * estimator.predict(X)
return result
def sparse_encode(X, dictionary, gram=None, cov=None, algorithm='lasso_lars',
n_nonzero_coefs=None, alpha=None, copy_cov=True, init=None,
max_iter=1000, n_jobs=1):
"""Sparse coding
Each row of the result is the solution to a sparse coding problem.
The goal is to find a sparse array `code` such that::
X ~= code * dictionary
Parameters
----------
X: array of shape (n_samples, n_features)
Data matrix
dictionary: array of shape (n_components, n_features)
The dictionary matrix against which to solve the sparse coding of
the data. Some of the algorithms assume normalized rows for meaningful
output.
gram: array, shape=(n_components, n_components)
Precomputed Gram matrix, dictionary * dictionary'
cov: array, shape=(n_components, n_samples)
Precomputed covariance, dictionary' * X
algorithm: {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}
lars: uses the least angle regression method (linear_model.lars_path)
lasso_lars: uses Lars to compute the Lasso solution
lasso_cd: uses the coordinate descent method to compute the
Lasso solution (linear_model.Lasso). lasso_lars will be faster if
the estimated components are sparse.
omp: uses orthogonal matching pursuit to estimate the sparse solution
threshold: squashes to zero all coefficients less than alpha from
the projection dictionary * X'
n_nonzero_coefs: int, 0.1 * n_features by default
Number of nonzero coefficients to target in each column of the
solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
and is overridden by `alpha` in the `omp` case.
alpha: float, 1. by default
If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
penalty applied to the L1 norm.
If `algorithm='threhold'`, `alpha` is the absolute value of the
threshold below which coefficients will be squashed to zero.
If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
the reconstruction error targeted. In this case, it overrides
`n_nonzero_coefs`.
init: array of shape (n_samples, n_components)
Initialization value of the sparse codes. Only used if
`algorithm='lasso_cd'`.
max_iter: int, 1000 by default
Maximum number of iterations to perform if `algorithm='lasso_cd'`.
copy_cov: boolean, optional
Whether to copy the precomputed covariance matrix; if False, it may be
overwritten.
n_jobs: int, optional
Number of parallel jobs to run.
Returns
-------
code: array of shape (n_samples, n_components)
The sparse codes
See also
--------
sklearn.linear_model.lars_path
sklearn.linear_model.orthogonal_mp
sklearn.linear_model.Lasso
SparseCoder
"""
dictionary = array2d(dictionary)
X = array2d(X)
n_samples, n_features = X.shape
n_components = dictionary.shape[0]
if gram is None and algorithm != 'threshold':
gram = np.dot(dictionary, dictionary.T)
if cov is None:
copy_cov = False
cov = np.dot(dictionary, X.T)
if algorithm in ('lars', 'omp'):
regularization = n_nonzero_coefs
if regularization is None:
regularization = max(n_features / 10, 1)
else:
regularization = alpha
if regularization is None:
regularization = 1.
if n_jobs == 1 or algorithm == 'threshold':
return _sparse_encode(X, dictionary, gram, cov=cov,
algorithm=algorithm,
regularization=regularization, copy_cov=copy_cov,
init=init, max_iter=max_iter)
# Enter parallel code block
code = np.empty((n_samples, n_components))
slices = list(gen_even_slices(n_samples, n_jobs))
code_views = Parallel(n_jobs=n_jobs)(
delayed(_sparse_encode)(
X[this_slice], dictionary, gram, cov[:, this_slice], algorithm,
regularization=regularization, copy_cov=copy_cov,
init=init[this_slice] if init is not None else None,
max_iter=max_iter)
for this_slice in slices)
for this_slice, this_view in zip(slices, code_views):
code[this_slice] = this_view
return code