def _lle(self, X):
W = self.barycenter_graph(X)
# find the null space of (I-W)
M = eye(*W.shape, format=W.format) - W
# symmetrize
M = (M.T * M).tocsr()
def fit(self, x, y_multiclass, kernel=poly(1), C=0.001):
y_multiclass=y_multiclass.reshape(-1).astype(np.float64)
self.x = sparse.COO(x.astype(np.float64))
self.m = self.x.shape[0]
self.y_multiclass = y_multiclass
self.kernel = kernel
self.C = C
ys = [sparse.COO(self.cast(y_multiclass, k)) for k in range(self.n_svm)]
self.y_matrix = sparse.stack(ys,0)
del ys
for k in range(self.n_svm):
print("training ",k,"th SVM in ",self.n_svm)
y = self.y_matrix[k, :].reshape((-1,1))
yx = y * self.x
G = kernel(yx, yx) # Gram matrix
compensate = (sparse.eye(self.m)*1e-7).astype(np.float64)
G = (G + compensate)
objective = cp.Maximize(cp.sum(self.a[k])-(1/2)*cp.quad_form(self.a[k], G.tocsr()))
if not objective.is_dcp():
print("Not solvable!")
assert objective.is_dcp()
constraints = [self.a[k] <= C, cp.sum(cp.multiply(self.a[k],y.todense())) == 0] # box constraint
prob = cp.Problem(objective, constraints)
result = prob.solve()
x_pos = x[y.todense()[:,0]==1,:]
x_neg = x[y.todense()[:,0]==-1,:]
b_min = -np.min(self.wTx(k,x_pos)) if x_pos.shape[0]!=0 else 0
b_max = -np.max(self.wTx(k,x_neg)) if x_neg.shape[0]!=0 else 0
self.b[k,0] = (1/2)*(b_min + b_max)
self.a_matrix = np.stack([i.value.reshape(-1) for i in self.a],0)
self.a_matrix = sparse.COO(self.a_matrix)
def _ident_like(A):
# A compatibility function which should eventually disappear.
if scipy.sparse.isspmatrix(A):
return scipy.sparse.construct.eye(A.shape[0], A.shape[1],
dtype=A.dtype, format=A.format)
elif is_pydata_spmatrix(A):
import sparse
return sparse.eye(A.shape[0], A.shape[1], dtype=A.dtype)
else:
return np.eye(A.shape[0], A.shape[1], dtype=A.dtype)
def _ident_like(A):
# A compatibility function which should eventually disappear.
if scipy.sparse.isspmatrix(A):
return scipy.sparse._construct.eye(A.shape[0], A.shape[1],
dtype=A.dtype, format=A.format)
elif is_pydata_spmatrix(A):
import sparse
return sparse.eye(A.shape[0], A.shape[1], dtype=A.dtype)
elif isinstance(A, scipy.sparse.linalg.LinearOperator):
return IdentityOperator(A.shape, dtype=A.dtype)
else:
return np.eye(A.shape[0], A.shape[1], dtype=A.dtype)
def partial_svd(self, matrix, n_eigenvecs=None, random_state=None, **kwargs):
# Check that matrix is... a matrix!
if matrix.ndim != 2:
raise ValueError('matrix be a matrix. matrix.ndim is {} != 2'.format(
matrix.ndim))
# Choose what to do depending on the params
dim_1, dim_2 = matrix.shape
if dim_1 <= dim_2:
min_dim = dim_1
else:
min_dim = dim_2
if not is_sparse(matrix) and (n_eigenvecs is None or n_eigenvecs >= min_dim):
if n_eigenvecs is None or n_eigenvecs > min_dim:
full_matrices = True
else:
full_matrices = False
# Default on standard SVD
U, S, V = scipy.linalg.svd(matrix, full_matrices=full_matrices)
U, S, V = U[:, :n_eigenvecs], S[:n_eigenvecs], V[:n_eigenvecs, :]
return U, S, V
elif n_eigenvecs is None:
raise ValueError('n_eigenvecs cannot be none')
elif is_sparse(matrix) and matrix.nnz == 0:
# all-zeros matrix, so we should do a quick return.
U = sparse.eye(dim_1, n_eigenvecs, dtype=matrix.dtype)
S = np.zeros(n_eigenvecs, dtype=matrix.dtype)
V = sparse.eye(dim_2, n_eigenvecs, dtype=matrix.dtype)
else:
if n_eigenvecs > min_dim:
msg = ('n_eigenvecs={} if greater than the minimum matrix '
'dimension ({})')
raise ValueError(msg.format(n_eigenvecs, min(matrix.shape)))
if np.issubdtype(matrix.dtype, np.complexfloating):
raise NotImplementedError("Complex dtypes")
# We can perform a partial SVD
rng = self.check_random_state(random_state)
# initilize with [-1, 1] as in ARPACK
v0 = rng.uniform(-1, 1, min_dim)
# First choose whether to use X * X.T or X.T *X
if dim_1 < dim_2:
conj = matrix.T
xxT = matrix.dot(conj)
if is_sparse(xxT):
xxT = xxT.to_scipy_sparse()
if n_eigenvecs >= xxT.shape[0]:
# use dense form when sparse form will fail
S, U = scipy.linalg.eigh(xxT.toarray())
else:
S, U = scipy.sparse.linalg.eigsh(xxT, k=n_eigenvecs, which='LM', v0=v0)
S = np.sqrt(S)
V = conj.dot(U / S[None, :])
else:
xTx = matrix.T.dot(matrix)
if is_sparse(xTx):
xTx = xTx.to_scipy_sparse()
if n_eigenvecs >= xTx.shape[0]:
# use dense form when sparse form will fail
S, V = scipy.linalg.eigh(xTx.toarray())
else:
S, V = scipy.sparse.linalg.eigsh(xTx, k=n_eigenvecs, which='LM', v0=v0)
S = np.sqrt(S)
U = matrix.dot(V / S[None, :])
# WARNING: here, V is still the transpose of what it should be
U, S, V = U[:, ::-1], S[::-1], V[:, ::-1]
return U, S, V.T.conj()
def mask_factory():
s = tuple(ds.shape.sig)
return sparse.eye(np.prod(s)).reshape((-1, *s))
def test_dask_array_is_sparse():
assert utils.is_dask_array_sparse(
da.from_array(sparse.COO([], [], shape=(10, 10))))
assert utils.is_dask_array_sparse(da.from_array(sparse.eye(10)))
assert not utils.is_dask_array_sparse(da.from_array(np.eye(10)))
