def fit(self, X, y):
"""Fit OVK ridge regression model.
Parameters
----------
X : {array-like, sparse matrix}, shape = [n_samples, n_features]
Training data.
y : {array-like}, shape = [n_samples] or [n_samples, n_targets]
Target values. numpy.NaN for missing targets (semi-supervised
learning).
Returns
-------
self : returns an instance of self.
"""
X = check_array(X, force_all_finite=True, accept_sparse=False,
ensure_2d=True)
y = check_array(y, force_all_finite=False, accept_sparse=False,
ensure_2d=False)
if y.ndim == 1:
y = check_array(y, force_all_finite=True, accept_sparse=False,
ensure_2d=False)
self._validate_params()
solver_params = self.solver_params or {}
self.linop_ = self._get_kernel_map(X, y)
Gram = self.linop_(X)
risk = OVKRidgeRisk(self.lbda)
if not issubdtype(y.dtype, number):
raise ValueError("Unknown label type: %r" % y.dtype)
if y.ndim > 1:
is_sup = ~all(isnan(y), axis=1)
else:
is_sup = ~isnan(y)
if sum(~is_sup) > 0:
self.L_ = _graph_Laplacian(rbf_kernel(X[~is_sup, :],
gamma=self.gamma_m))
else:
self.L_ = empty((0, 0))
p = y.shape[1] if y.ndim > 1 else 1
weight, zeronan = _SemisupLinop(self.lbda_m, is_sup, self.L_, p).gen()
self.solver_res_ = minimize(risk.functional_grad_val,
zeros(Gram.shape[1]),
args=(y.ravel(), Gram, weight, zeronan),
method=self.solver,
jac=True,
options=solver_params)
self.dual_coefs_ = self.solver_res_.x
return self
python类rbf_kernel()的实例源码
def test_pairwise_kernels(): # Test the pairwise_kernels helper function.
rng = np.random.RandomState(0)
X = rng.random_sample((5, 4))
Y = rng.random_sample((2, 4))
# Test with all metrics that should be in PAIRWISE_KERNEL_FUNCTIONS.
test_metrics = ["rbf", "laplacian", "sigmoid", "polynomial", "linear",
"chi2", "additive_chi2"]
for metric in test_metrics:
function = PAIRWISE_KERNEL_FUNCTIONS[metric]
# Test with Y=None
K1 = pairwise_kernels(X, metric=metric)
K2 = function(X)
assert_array_almost_equal(K1, K2)
# Test with Y=Y
K1 = pairwise_kernels(X, Y=Y, metric=metric)
K2 = function(X, Y=Y)
assert_array_almost_equal(K1, K2)
# Test with tuples as X and Y
X_tuples = tuple([tuple([v for v in row]) for row in X])
Y_tuples = tuple([tuple([v for v in row]) for row in Y])
K2 = pairwise_kernels(X_tuples, Y_tuples, metric=metric)
assert_array_almost_equal(K1, K2)
# Test with sparse X and Y
X_sparse = csr_matrix(X)
Y_sparse = csr_matrix(Y)
if metric in ["chi2", "additive_chi2"]:
# these don't support sparse matrices yet
assert_raises(ValueError, pairwise_kernels,
X_sparse, Y=Y_sparse, metric=metric)
continue
K1 = pairwise_kernels(X_sparse, Y=Y_sparse, metric=metric)
assert_array_almost_equal(K1, K2)
# Test with a callable function, with given keywords.
metric = callable_rbf_kernel
kwds = {'gamma': 0.1}
K1 = pairwise_kernels(X, Y=Y, metric=metric, **kwds)
K2 = rbf_kernel(X, Y=Y, **kwds)
assert_array_almost_equal(K1, K2)
# callable function, X=Y
K1 = pairwise_kernels(X, Y=X, metric=metric, **kwds)
K2 = rbf_kernel(X, Y=X, **kwds)
assert_array_almost_equal(K1, K2)
