def get_rotation_matrix(M, Mtilde, weights=None, dist=None): if dist is None: dist = 'euc' n = M[0].shape[0] # (1) Instantiate a manifold manifold = Rotations(n) # (2) Define cost function and a problem if dist == 'euc': cost = partial(cost_function_full, M=M, Mtilde=Mtilde, weights=weights, dist=dist) problem = Problem(manifold=manifold, cost=cost, verbosity=0) elif dist == 'rie': cost = partial(cost_function_full, M=M, Mtilde=Mtilde, weights=weights, dist=dist) egrad = partial(egrad_function_full_rie, M=M, Mtilde=Mtilde, weights=weights) problem = Problem(manifold=manifold, cost=cost, egrad=egrad, verbosity=0) # (3) Instantiate a Pymanopt solver solver = SteepestDescent(mingradnorm=1e-3) # let Pymanopt do the rest Q_opt = solver.solve(problem) return Q_opt
def run(backend=SUPPORTED_BACKENDS[0], quiet=True): # Generate random problem data. n = 128 A = np.random.randn(n, n) A = 0.5 * (A + A.T) cost, egrad = create_cost_egrad(backend, A) # Create the problem structure. manifold = Sphere(n) problem = Problem(manifold=manifold, cost=cost, egrad=egrad) if quiet: problem.verbosity = 0 # Numerically check gradient consistency (optional). check_gradient(problem)
def envelope(X_env, Y_env, u): p, r = X_env.shape[1], Y_env.shape[1] linear_model = LinearRegression().fit(X_env, Y_env) err = Y_env - linear_model.predict(X_env) Sigma_res = np.cov(err.transpose()) Sigma_Y = np.cov(Y_env.transpose()) def cost(Gamma): X = np.matmul(Gamma, Gamma.T) out = -np.log( np.linalg.det( np.matmul(np.matmul(X, Sigma_res), X) + np.matmul(np.matmul(np.eye(r) - X, Sigma_Y), np.eye(r) - X))) return (np.array(out)) manifold = Grassmann(r, u) # manifold = Stiefel(r, u) problem = Problem(manifold=manifold, cost=cost, verbosity=0) solver = SteepestDescent() Gamma = solver.solve(problem) PSigma1_hat = np.matmul(Gamma, Gamma.T) PSigma2_hat = np.eye(r) - PSigma1_hat beta_hat = np.matmul(PSigma1_hat, linear_model.coef_) Sigma1_hat = np.matmul(np.matmul(PSigma1_hat, Sigma_res), PSigma1_hat) Sigma2_hat = np.matmul(np.matmul(np.eye(r) - PSigma1_hat, Sigma_res), np.eye(r) - PSigma1_hat) alpha_hat = np.mean(Y_env - np.matmul(X_env, beta_hat.T), axis=0) return (alpha_hat.reshape(1, r), beta_hat.reshape(p, r))
def optimize_AB(Cor11, Cor21, n, V11, V21, D11, D21, k): global D2 global V1 global V2 global Cor1 global Cor2 global k_ D2 = D21 V1 = V11 V2 = V21 Cor1 = Cor11 Cor2 = Cor21 k_ = k manifold = Stiefel(k, k) x0 = init_x0(Cor1, Cor2, n, V1, V2, D1, D2, k) # x0=np.load('zwischenspeicher/B.npy') problem = Problem(manifold=manifold, cost=cost) # (3) Instantiate a Pymanopt solver #solver = pymanopt.solvers.conjugate_gradient.ConjugateGradient(maxtime=10000, maxiter=10000) solver = pymanopt.solvers.trust_regions.TrustRegions( ) # maxtime=float('inf')) # let Pymanopt do the rest B = solver.solve(problem, x=x0) # print(B) # print(np.reshape(res.x[0:k*k_],(k_,k))[email protected](res.x[0:k*k_],(k_,k))) return B
def fixedrank(A, YT, r): """ Solves the AX=YT problem on the manifold of r-rank matrices with """ # Instantiate a manifold manifold = FixedRankEmbedded(N, r, r) # Define the cost function (here using autograd.numpy) def cost(X): U = X[0] cst = 0 for n in range(N): cst = cst + huber(U[n, :]) Mat = np.matmul(np.matmul(X[0], np.diag(X[1])), X[2]) fidelity = LA.norm(np.subtract(np.matmul(A, Mat), YT)) return cst + lambd * fidelity**2 problem = Problem(manifold=manifold, cost=cost) solver = ConjugateGradient(maxiter=maxiter) # Let Pymanopt do the rest Xopt = solver.solve(problem) #Solve Sol = np.dot(np.dot(Xopt[0], np.diag(Xopt[1])), Xopt[2]) return Sol
def max_GtRq_brute(A, B, feedback=0, optimizer='ParticleSwarm', **kwargs): """ Brute force maximization of the Generalized Tensor Rayleigh quotient on the sphere. Optimization is performed with Pymanopt. :param A: the input tensor :param B: the second input tensor :param feedback: the feedback level for pymanopt :param optimizer: the name of the pymanopt minimizer :param kwargs: keyword arguments to pass to the pymanopt solver """ # get dimension: d = A.shape[0] # initialize: manifold = Sphere(d) problem = Problem(manifold=manifold, cost=lambda x: -_GtRq_brute_autograd(x, A, B), verbosity=feedback) # optimization: if optimizer == 'ParticleSwarm': solver = pymanopt.solvers.ParticleSwarm(logverbosity=0, **kwargs) Xopt = solver.solve(problem) elif optimizer == 'TrustRegions': solver = pymanopt.solvers.TrustRegions(logverbosity=0, **kwargs) Xopt = solver.solve(problem) # finalize: return _GtRq_brute_autograd(Xopt, A, B), Xopt
def CGmanopt(X, objective_function, A, **kwargs): ''' Minimizes the objective function subject to the constraint that X.T * X = I_k using the conjugate gradient method Args: X: Initial 2D array of shape (n, k) such that X.T * X = I_k objective_function: Objective function F(X, A) to minimize. A: Additional parameters for the objective function F(X, A) Keyword Args: None Returns: Xopt: Value of X that minimizes the objective subject to the constraint. ''' manifold = Stiefel(X.shape[0], X.shape[1]) def cost(X): c, _ = objective_function(X, A) return c problem = Problem(manifold=manifold, cost=cost, verbosity=0) solver = ConjugateGradient(logverbosity=0) Xopt = solver.solve(problem) return Xopt, None
def solve_dist_with_man(man, A, X0, maxiter): from pymanopt import Problem from pymanopt.solvers import TrustRegions from pymanopt.function import Callable @Callable def cost(S): # if not(S.P.dtype == np.float): # raise(ValueError("Non real")) diff = (A - S.U @ S.P @ S.V.T.conj()) val = rtrace(diff @ diff.T.conj()) # print('val=%f' % val) return val @Callable def egrad(S): return fr_ambient(-2*A @ S.V @ S.P, -2*A.T.conj() @ S.U @S.P, 2*(S.P-S.U.T.conj() @ A @ S.V)) @Callable def ehess(S, xi): return fr_ambient(-2*A @ (xi.tV @ S.P + S.V @ xi.tP), -2*A.T.conj() @ (xi.tU @S.P + [email protected]), 2*(xi.tP - xi.tU.T.conj()@[email protected] - S.U.T.conj()@[email protected])) prob = Problem( man, cost, egrad=egrad, ehess=ehess) solver = TrustRegions(maxtime=100000, maxiter=maxiter, use_rand=False) opt = solver.solve(prob, x=X0, Delta_bar=250) return opt
def compute_centroid(man, x): """ Compute the centroid as Karcher mean of points x belonging to the manifold man. """ n = len(x) def objective(y): # weighted Frechet variance acc = 0 for i in range(n): acc += man.dist(y, x[i])**2 return acc / 2 def gradient(y): g = man.zerovec(y) for i in range(n): g -= man.log(y, x[i]) return g # TODO: manopt runs a few TR iterations here. For us to do this, we either # need to work out the Hessian of the Frechet variance by hand or # implement approximations for the Hessian to use in the TR solver. # This is because we cannot implement the Frechet variance with # theano and compute the Hessian automatically due to dependency on # the manifold-dependent distance function. solver = SteepestDescent(maxiter=15) problem = Problem(man, cost=objective, grad=gradient, verbosity=0) return solver.solve(problem)
def rotation_matrix(mean_source, mean_target_train): manifold = Rotations(mean_source[0].shape[0]) cost = partial(cost_function_full, mean_source, mean_target_train) problem = Problem(manifold, cost) solver = SteepestDescent(mingradnorm=1e-3) U = solver.solve(problem) return U
def train_model(self, x0=None): self.U = T.matrix('U') self.S = T.matrix('S') self.V = T.matrix('V') problem = Problem(man=self.manifold, theano_cost=self.log_likelihood(), theano_arg=[self.U, self.S, self.V]) if x0 is None: user_vectors = np.random.normal(size=(self.num_users, self.num_factors + 1)) item_vectors = np.random.normal(size=(self.num_items, self.num_factors + 1)) s = rnd.random(self.num_factors + 1) s[:-1] = np.sort(s[:-1])[::-1] x0 = (user_vectors, np.diag(s), item_vectors.T) else: x0 = x0 (left, middle, right), self.loss_history = self.solver.solve(problem, x=x0) right = right.T s_mid = np.diag(np.sqrt(np.diag(middle)[:-1])) self.middle = s_mid print('U norm: {}'.format(la.norm(left[:, :-1]))) print('V norm: {}'.format(la.norm(right[:, :-1]))) self.user_vectors = left[:, :-1].dot(s_mid) self.item_vectors = right[:, :-1].dot(s_mid) self.user_biases = left[:, -1] * np.sqrt(middle[-1, -1]) self.item_biases = right[:, -1] * np.sqrt(middle[-1, -1]) print('U norm: {}'.format(la.norm(self.user_vectors))) print('V norm: {}'.format(la.norm(self.item_vectors))) print('LL: {}'.format(self._log_likelihood()))
def fit(self): v_matrix_shape = (self.w_matrix.shape[0], self.w_matrix.shape[1]) w_matrix = tf.convert_to_tensor(self.w_matrix, dtype=tf.float64) z_matrix = tf.convert_to_tensor(self.z_matrix, dtype=tf.float64) x_matrix = tf.convert_to_tensor(self.x_matrix, dtype=tf.float64) lambda_matrix = tf.convert_to_tensor(self.lambda_matrix, dtype=tf.float64) x = tf.Variable( initial_value=tf.ones(v_matrix_shape, dtype=tf.dtypes.float64)) cost = tf.norm(x_matrix - tf.linalg.matmul( tf.linalg.matmul(x, lambda_matrix), tf.transpose(x)) ) + self.rho / 2 * tf.norm(x - w_matrix + z_matrix) manifold = Stiefel(v_matrix_shape[0], v_matrix_shape[1]) problem = Problem(manifold=manifold, cost=cost, arg=x) solver = SteepestDescent(logverbosity=self.verbosity) if self.verbosity > 2: v_optimal, _ = solver.solve(problem) else: v_optimal = solver.solve(problem) if self.verbosity > 2: print("==> WSubproblem ==> Showing v_optimal:") print(v_optimal) return v_optimal
def train_model(self, x0=None): self.L = T.matrix('L') self.R = T.matrix('R') problem = Problem(man=self.manifold, theano_cost=self.log_likelihood(), theano_arg=[self.L, self.R]) if x0 is None: user_vectors = np.random.normal(size=(self.num_users, self.num_factors)) item_vectors = np.random.normal(size=(self.num_items, self.num_factors)) user_biases = np.random.normal(size=(self.num_users, 1)) / SCONST item_biases = np.random.normal(size=(self.num_items, 1)) / SCONST x0 = (np.hstack((user_vectors, user_biases)), np.hstack((item_vectors, item_biases))) else: x0 = x0 (left, right), self.loss_history = self.solver.solve(problem, x=x0) self.user_vectors = left[:, :-1] self.item_vectors = right[:, :-1] self.user_biases = left[:, -1].reshape((self.num_users, 1)) self.item_biases = right[:, -1].reshape((self.num_items, 1)) print('U norm: {}'.format(la.norm(self.user_vectors))) print('V norm: {}'.format(la.norm(self.item_vectors)))
def _align_H_stiefel(self, Q, G): """Tangent vector field alignment via optimization on orthogonal group.""" N, D, d = Q.shape indptr = G.indptr indices = G.indices K = G.data def cost(V): F = 0 for i in range(N): for j, K_ij in zip(indices[indptr[i]:indptr[i + 1]], K[indptr[i]:indptr[i + 1]]): f_i = K_ij * np.trace( np.dot(np.dot(V[i].T, np.dot(Q[i].T, Q[j])), V[j])) F += f_i return F manifold = Rotations(d) problem = Problem(manifold=manifold, cost=cost) solver = SteepestDescent() V = solver.solve(problem, np.zeros((d, d))) return H
def fit(self): f = self.f X = self.X tol = self.tol d = self.d n = self.n current_best_residual = np.inf for r in range(self.restarts): print('restart %d' % r) M0 = np.linalg.qr(np.random.randn(self.d, self.n))[0] my_params = [Parameter(order=self.order, distribution='uniform', lower=-5, upper=5) for _ in range(n)] my_basis = Basis('total-order') my_poly_init = Poly(parameters=my_params, basis=my_basis, method='least-squares', sampling_args={'mesh': 'user-defined', 'sample-points': X @ M0, 'sample-outputs': f}) my_poly_init.set_model() c0 = my_poly_init.coefficients.copy() residual = self.cost(f, X, M0, c0) cauchy_length = self.cauchy_length residual_history = [] iter_ind = 0 M = M0.copy() c = c0.copy() while residual > tol: if self.verbosity == 2: print(residual) residual_history.append(residual) # Minimize over M func_M = lambda M_var: self.cost(f, X, M_var, c) grad_M = lambda M_var: self.dcostdM(f, X, M_var, c) manifold = Stiefel(d, n) solver = ConjugateGradient(maxiter=self.max_M_iters) problem = Problem(manifold=manifold, cost=func_M, egrad=grad_M, verbosity=0) M = solver.solve(problem, x=M) # Minimize over c func_c = lambda c_var: self.cost(f, X, M, c_var) grad_c = lambda c_var: self.dcostdc(f, X, M, c_var) res = minimize(func_c, x0=c, method='CG', jac=grad_c) c = res.x residual = self.cost(f, X, M, c) if iter_ind < cauchy_length: iter_ind += 1 elif np.abs(np.mean(residual_history[-cauchy_length:]) - residual)/residual < self.cauchy_tol: break if self.verbosity > 0: print('final residual on training data: %f' % self.cost(f, X, M, c)) if residual < current_best_residual: self.M = M self.c = c current_best_residual = residual
def test_prepare(self): problem = Problem(self.man, self.cost) with self.assertRaises(ValueError): # Asking for the gradient of a Theano cost function without # specifying an argument for differentiation should raise an # exception. problem.grad
def low_rank_matrix_approximation_theano(A, k): manifold, solver = _bootstrap_problem(A, k) Y = T.matrix() cost = T.sum((T.dot(Y, Y.T) - A)**2) problem = Problem(man=manifold, theano_cost=cost, theano_arg=Y) return solver.solve(problem)
def solve_manopt(X, d, cost, egrad, Wo=None): D = X.shape[1] manifold = Grassmann(height=D, width=d) problem = Problem(manifold=manifold, cost=cost, egrad=egrad, verbosity=0) solver = ConjugateGradient(mingradnorm=1e-3) W = solver.solve(problem, x=Wo) return W
def get_rotation_matrix(X, C): def cost(R): Z = npy.dot(X, R) M = npy.max(Z, axis=1, keepdims=True) return npy.sum((Z / M)**2) manifold = Stiefel(C, C) problem = Problem(manifold=manifold, cost=cost, verbosity=0) solver = SteepestDescent(logverbosity=0) opt = solver.solve(problem=problem, x=npy.eye(C)) return cost(opt), opt
def estimateR_weighted(S, W, D, R0): ''' estimates the update of the rotation matrix for the second part of the iterations :param S : shape :param W : heatmap :param D : weight of the heatmap :param R0 : rotation matrix :return: R the new rotation matrix ''' A = np.transpose(S) B = np.transpose(W) X0 = R0[0:2, :] store_E = Store() [m, n] = A.shape p = B.shape[1] At = np.zeros([n, m]) At = np.transpose(A) # we use the optimization on a Stiefel manifold because R is constrained to be othogonal manifold = Stiefel(n, p, 1) #################################################################################################################### def cost(X): ''' cost function of the manifold, the cost is trace(E'*D*E)/2 with E = A*X - B or store_E :param X : vector :return f : the cost ''' if store_E.stored is None: store_E.stored = np.dot(A, np.transpose(X)) - B E = store_E.stored f = np.trace(np.dot(np.transpose(E), np.dot(D, E))) / 2 return f #################################################################################################################### # setup the problem structure with manifold M and cost problem = Problem(manifold=manifold, cost=cost, verbosity=0) # setup the trust region algorithm to solve the problem TR = TrustRegions(maxiter=10) # solve the problem X = TR.solve(problem, X0) #print('X : ',X) return np.transpose(X) # return R = X'
def NG_sdr(X, y, m, v_w = 5, v_b = 5, verbosity=0, *args, **kwargs): """ X: array of N points on complex Gr(n, p); N x n x p array aim to represent X by X_hat (N points on Gr(m, p), m < n) where X_hat_i = R^T X_i, W \in St(n, m) minimizing the projection error (using projection F-norm) """ N, n, p = X.shape cpx = np.iscomplex(X).any() # true if X is complex-valued if cpx: gr = ComplexGrassmann(n, p) man = ComplexGrassmann(n, m) else: gr = Grassmann(n, p) man = Grassmann(n, m) # distance matrix dist_m = np.zeros((N, N)) for i in range(N): for j in range(i): dist_m[i, j] = gr.dist(X[i], X[j]) dist_m[j, i] = dist_m[i, j] # affinity matrix affinity = affinity_matrix(dist_m, y, v_w, v_b) X_ = torch.from_numpy(X) affinity_ = torch.from_numpy(affinity) @pymanopt.function.PyTorch def cost(A): dm = torch.zeros((N, N)) for i in range(N): for j in range(i): dm[i, j] = dist_proj(torch.matmul(A.conj().t(), X_[i]), torch.matmul(A.conj().t(), X_[j]))**2 #dm[i, j] = gr_low.dist(X_proj[i], X_proj[j])**2 dm[j, i] = dm[i, j] d2 = torch.mean(affinity_*dm) return d2 # solver = ConjugateGradient() solver = SteepestDescent() problem = Problem(manifold=man, cost=cost, verbosity=verbosity) A = solver.solve(problem) tmp = np.array([A.conj().T for i in range(N)]) # N x m x n X_low = multiprod(tmp, X) # N x m x p X_low = np.array([qr(X_low[i])[0] for i in range(N)]) return X_low, A
def NG_dr1(X, verbosity = 0): """ X: array of N points on Gr(n, p); N x n x p array aim to represent X by X_hat (N points on Gr(n-1, p)) where X_hat_i = A^T X_i, A \in St(n, n-1) minimizing the projection error (using projection F-norm) """ N, n, p = X.shape cpx = np.iscomplex(X).any() # true if X is complex-valued if cpx: man = Product([ComplexGrassmann(n, 1), Euclidean(p, 2)]) else: man = Product([Grassmann(n, 1), Euclidean(p)]) X_ = torch.from_numpy(X) @pymanopt.function.PyTorch def cost(v, b): vvT = torch.matmul(v, v.conj().t()) # n x n if cpx: b_ = b[:,0] + b[:,1]*1j b_ = torch.unsqueeze(b_, axis=1) else: b_ = torch.unsqueeze(b, axis=1) vbt = torch.matmul(v, b_.t()) # n x p IvvT = torch.eye(n, dtype=X_.dtype) - vvT d2 = 0 for i in range(N): d2 = d2 + dist_proj(X_[i], torch.matmul(IvvT, X_[i]) + vbt)**2/N #d2 = d2 + dist_proj(X_[i], torch.matmul(AAT, X_[i]))**2/N return d2 solver = SteepestDescent() problem = Problem(manifold=man, cost=cost, verbosity=verbosity) theta = solver.solve(problem) v = theta[0] b_ = theta[1] if cpx: b = b_[:,0] + b_[:,1]*1j b = np.expand_dims(b, axis=1) else: b = np.expand_dims(b_, axis=1) R = ortho_complement(v) tmp = np.array([R.conj().T for i in range(N)]) X_low = multiprod(tmp, X) X_low = np.array([qr(X_low[i])[0] for i in range(N)]) return X_low, R, v, b
def estimate_orth_subspaces(self, DataStruct): ''' main optimization function ''' # Grassman point? if LA.norm(np.dot(self.Q.T, self.Q) - np.eye(self.Q.shape[-1]), ord='fro') > 1e-4: self._project_stiefel() # ----------------------------------------------------------------------- # # eGrad = grad(cost) # eHess = hessian(cost) # Perform optimization # ----------------------------------------------------------------------- # # ----------------------------------------------------------------------- # d, r = np.shape(self.Q) # problem size print(d) manif = Stiefel(d, r) # initialize manifold # instantiate problem problem = Problem(manifold=manif, cost=self._cost, verbosity=2) # initialize solver solver = TrustRegions(mingradnorm=1e-8, minstepsize=1e-16, logverbosity=1) # solve Xopt, optlog = solver.solve(problem) opt_subspaces = self._objfn(Xopt) # Align the axes within a subspace by variance high to low for j in range(self.numSubspaces): Aj = DataStruct.A[j] Qj = opt_subspaces[2].Q[j] # data projected onto subspace Aj_proj = np.dot((Aj - np.mean(Aj, 0)), Qj) if np.size(np.cov(Aj_proj.T)) < 2: V = 1 else: V = LA.svd(np.cov(Aj_proj.T))[0] Qj = np.dot(Qj, V) opt_subspaces[2].Q[j] = Qj # ranked top to low variance return opt_subspaces[2]
def get_rotation_matrix(Mt, Ms, metric='euc'): Mt = Mt.reshape(-1, *Mt.shape[-2:]) Ms = Ms.reshape(-1, *Ms.shape[-2:]) n = Mt[0].shape[0] manifolds = Rotations(n) if metric == 'euc': cost = partial(_procruster_cost_function_euc, Mt=Mt, Ms=Ms) problem = Problem(manifold=manifolds, cost=cost, verbosity=0) elif metric == 'rie': cost = partial(_procruster_cost_function_rie, Mt=Mt, Ms=Ms) egrad = partial(_procruster_egrad_function_rie, Mt=Mt, Ms=Ms) problem = Problem(manifold=manifolds, cost=cost, egrad=egrad, verbosity=0) solver = SteepestDescent(mingradnorm=1e-3) Ropt = solver.solve(problem) return Ropt
def NG_dr(X, m, verbosity=0, *args, **kwargs): """ X: array of N points on Gr(n, p); N x n x p array aim to represent X by X_hat (N points on Gr(m, p), m < n) where X_hat_i = R^T X_i, R \in St(n, m) minimizing the projection error (using projection F-norm) """ N, n, p = X.shape cpx = np.iscomplex(X).any() # true if X is complex-valued if cpx: man = Product([ComplexGrassmann(n, m), Euclidean(n, p, 2)]) else: man = Product([Grassmann(n, m), Euclidean(n, p)]) X_ = torch.from_numpy(X) @pymanopt.function.PyTorch def cost(A, B): AAT = torch.matmul(A, A.conj().t()) # n x n if cpx: B_ = B[:,:,0] + B[:,:,1]*1j else: B_ = B IAATB = torch.matmul(torch.eye(n, dtype=X_.dtype) - AAT, B_) # n x p d2 = 0 for i in range(N): d2 = d2 + dist_proj(X_[i], torch.matmul(AAT, X_[i]) + IAATB)**2/N #d2 = d2 + dist_proj(X_[i], torch.matmul(AAT, X_[i]))**2/N return d2 #solver = ConjugateGradient() solver = SteepestDescent() problem = Problem(manifold=man, cost=cost, verbosity=verbosity) theta = solver.solve(problem) A = theta[0] B = theta[1] if cpx: B_ = B[:,:,0] + B[:,:,1]*1j else: B_ = B #tmp = np.array([A.T for i in range(N)]) tmp = np.array([A.conj().T for i in range(N)]) X_low = multiprod(tmp, X) X_low = np.array([qr(X_low[i])[0] for i in range(N)]) return X_low, A, B_
def ManoptOptimization(A, m): n = A.shape[0] T = A.shape[2] manifold = Stiefel(n, m, k=1) mycost = lambda x: cost(A, x) myegrad = lambda x: egrad(A, x) problem = Problem(manifold=manifold, cost=mycost, egrad=myegrad) solver = TrustRegions() print('# Start optimization using solver: trustregion') Xopt = solver.solve(problem) return Xopt
def closest_unit_norm_column_approximation(A): """ Returns the matrix with unit-norm columns that is closests to A w.r.t. the Frobenius norm. """ m, n = A.shape manifold = Oblique(m, n) solver = ConjugateGradient() X = T.matrix() cost = 0.5 * T.sum((X - A)**2) problem = Problem(manifold=manifold, cost=cost, arg=X) return solver.solve(problem)
def low_rank_matrix_approximation(A, k): manifold, solver = _bootstrap_problem(A, k) def cost(Y): return la.norm(Y.dot(Y.T) - A, "fro")**2 def egrad(Y): return 4 * (Y.dot(Y.T) - A).dot(Y) def ehess(Y, U): return 4 * ((Y.dot(U.T) + U.dot(Y.T)).dot(Y) + (Y.dot(Y.T) - A).dot(U)) problem = Problem(man=manifold, cost=cost, egrad=egrad, ehess=ehess) return solver.solve(problem)
def run(backend=SUPPORTED_BACKENDS[0], quiet=True): n = 128 manifold = Sphere(n) # Generate random problem data. matrix = np.random.normal(size=(n, n)) matrix = 0.5 * (matrix + matrix.T) cost, euclidean_gradient = create_cost_and_derivates( manifold, matrix, backend) # Create the problem structure. problem = Problem(manifold, cost, euclidean_gradient=euclidean_gradient) # Numerically check gradient consistency (optional). check_gradient(problem)
def solve_manopt(X, d, cost, egrad): D = X.shape[1] manifold = Grassmann(height=D, width=d) problem = Problem(manifold=manifold, cost=cost, egrad=egrad, verbosity=0) solver = ConjugateGradient(mingradnorm=1e-3) M = mean_riemann(X) w, v = np.linalg.eig(M) idx = w.argsort()[::-1] v_ = v[:, idx] Wo = v_[:, :d] W = solver.solve(problem, x=Wo) return W
#https://github.com/pymanopt/pymanopt/blob/master/pymanopt/core/problem.py import autograd.numpy as np from pymanopt import Problem def cost(theta): return np.square(theta) problem = Problem(manifold=None, cost=cost, verbosity=1) print problem.cost(5) print problem.egrad(5.0)