def __init__(self, data, target): self.data = matrix(data).trans() self.target = matrix(target) self.Pmatrix = matrix(0, (self.data.size[0], self.data.size[0]), 'd') self.q = matrix(-1, (self.data.size[0],1),'d') self.h = matrix(0, (self.data.size[0],1), 'd') self.G = spdiag(matrix(-1, (1, self.data.size[0]), 'd')) self.alphas = [] self.alphas_x = [] self.G_slack = matrix([self.G, spdiag(matrix(1, (1, self.data.size[0]), 'd'))]) self.h_slack = matrix([self.h, matrix(1, (self.data.size[0],1), 'd')] )
def F(x=None, z=None): if x is None: return 0, matrix(0.5, (n, 1)) if min(x) <= 0.0: return None f = sum(x) Df = -(x**-1).T if z is None: return f, Df H = spdiag(z[0] * x**-2) return f, Df, H
def train(self,N=1,k=1): from dig_parser import DIGParser self._dig_parser = DIGParser() Q = spdiag([2]*self.features_size) G = spmatrix(0,[0],[0],(k,self.features_size)) Wc = spmatrix(0,[0],[0],(self.features_size,1)) self.v = spmatrix(0,[0],[0],(self.features_size,1)) complete = N * len(self._training_data) round = 0 for loop in range(N): for tid,(W,T,A,H) in enumerate(self._training_data): round += 1 print 'round %d/%d'%(round,complete) F = self.features_instance[tid] gold_deps,gold_features = [],Features() for c,h in enumerate(H): if h != -1: gold_deps.append((h,c)) if h > c: gold_features += F['%d-%d-L'%(c,h)] else: gold_features += F['%d-%d-R'%(h,c)] gold_deps.sort() print 'creating score table...' Sc = self._create_Sc(W,T,F,Wc) text = [] for i in range(1,len(W),1): text.append('%s/%s'%(W[i],T[i])) text = ' '.join(text) print 'input length = %d'%(len(W)) print 'parsing %d best...'%(k) trees = self._dig_parser.parse_mira_tagged_text(text,Sc,k,format='naist') n_trees = len(trees) if n_trees < k: for j in range(k-n_trees): trees.append(trees[-1]) print 'updating weight...' Wc = self._update_weight(Q,G,Wc,F,gold_deps,gold_features,trees) self.v = self.v + Wc print 'done\n'
def Lplus(L): try: nrow,ncol = L.shape Lcoo = L.tocoo() L = spmatrix(Lcoo.data.tolist(),Lcoo.row.tolist(),Lcoo.col.tolist()) except AttributeError: nrow,ncol = L.size ones = matrix(-1.0/nrow,(nrow,ncol)) ones+= spdiag(matrix(1.0,(1,nrow))) red = L[:-1,:-1] sol = ones[:-1,:] linsolve(red,sol,uplo='L') sol = array(sol) s = matrix(0.0,(1,ncol)) s[0,:]=sol.sum(0)/nrow lplus = zeros((nrow,ncol)) lplus[nrow-1,:] = -s[0,:] lplus[:-1,:] = sol-s return array(lplus)
def what_is_the_matrix(X, Z): """find the optimal morphing matrix A such that A * src_dist = target_dist""" #print "============ What is the Matrix? ===============" n = len(Z) N = n**2 #print "X =", X.T #print "Z =", Z.T # Equality Constraints A_list = [] b_list = [] # -- the columns of the matrix must be valid PDF's A_pdf = matrix(0.0, (n, N), 'd') for i in range(n): A_pdf[i, n * i:n * i + n] = 1.0 b_pdf = matrix(1.0, (n, 1), 'd') #print "A_pdf =" #print A_pdf #print "b_pdf =" #print b_pdf A_list.append(A_pdf) b_list.append(b_pdf) # -- the matrix must morph X to Z A_morph = matrix(0.0, (n, N), 'd') for i in range(n): matrix_vers = matrix(0.0, (n, n), 'd') matrix_vers[i, :] = X.T row = matrix(matrix_vers, (1, N), 'd') A_morph[i, :] = row b_morph = matrix(Z, (n, 1), 'd') A_list.append(A_morph) b_list.append(b_morph) #print "A_morph =" #print A_morph #print "b_morph =" #print b_morph # concatenate all our equality constraints into one coeff matrix and one b vector #A_list = [A_morph, A_pdf] #b_list = [b_morph, b_pdf] #A_list = [A_pdf] #b_list = [b_pdf] #A = matrix(A_list) A = sparse(A_list) b = matrix(b_list) #print "A =" #print A #print "b =" #print b # Inequality Constraints -- in order to be a valid PDF, each cell a_ij must be 0 <= a_ij <= 1 G_list = [] h_list = [] G_lt = spdiag(matrix(1.0, (N, 1), 'd')) h_lt = matrix(1.0, (N, 1), 'd') # cvw: as mentioned in the comment above in find_the_one(), the "less than" constraints are # in fact redundant given that we already require the columns to sum to 1.0 and require # (below) that each prob is >= 0. yay for smaller KKT matrices. #G_list.append(G_lt) #h_list.append(h_lt) G_gt = spdiag(matrix(-1.0, (N, 1), 'd')) h_gt = matrix(0.0, (N, 1), 'd') G_list.append(G_gt) h_list.append(h_gt) # cvw: I guess we could add some more constraints if we really wanted to.. # i.e. only downgrade the bit rate 10% of the time or less # but for now these'll do G = sparse(G_list) h = matrix(h_list) #print "G =" #print G #print "h =" #print h #print "vectorized cost matrix =" #print c.T # now run the cvxopt solver to get our answer #print "running cvxopt lp() solver..." ans = solvers.lp(cost_matrix, G=G, h=h, A=A, b=b, solver='glpk') ##print ans['x'] #print "answer = ", ans A = None if ans['x']: cost = cost_matrix.T * ans['x'] # A is the morphing matrix A = matrix(ans['x'], (n, n), 'd') return A
def sysid(y, u, vsig, svth=None): """ System identification using the subspace method and nuclear norm optimization. Estimate a linear time-invariant state-space model given inputs and outputs. The algorithm is described in [1]. INPUT y 'd' matrix of size (p, N). y are the measured outputs, p is the number of outputs, and N is the number of data points measured. u 'd' matrix of size (m, N). u are the inputs, m is the number of inputs, and N is the number of data points. vsig a weighting parameter in the nuclear norm optimization, its value is approximately the 1-sigma output noise level svth an optional parameter, if specified, the model order is determined as the number of singular values greater than svth times the maximum singular value. The default value is 1E-3 OUTPUT sol a dictionary with the following words -- 'A', 'B', 'C', 'D' are the state-space matrices -- 'svN', the original singular values of the Hankel matrix -- 'sv', the optimized singular values of the Hankel matrix -- 'x0', the initial state x(0) -- 'n', the model order [1] Zhang Liu and Lieven Vandenberghe. "Interior-point method for nuclear norm approximation with application to system identification." """ m, N, p = u.size[0], u.size[1], y.size[0] if y.size[1] != N: raise ValueError, "y and u must have the same length" # Y = G*X + H*U + V, Y has size a x b, U has size c x b, Un has b x d r = min(int(30 / p), int((N + 1.0) / (p + m + 1) + 1.0)) a = r * p c = r * m b = N - r + 1 d = b - c # construct Hankel matrix Y Y = Hankel(y, r, b, p=p, q=1) # construct Hankel matrix U U = Hankel(u, r, b, p=m, q=1) # compute Un = null(U) and YUn = Y*Un Vt = matrix(0.0, (b, b)) Stemp = matrix(0.0, (c, 1)) Un = matrix(0.0, (b, d)) YUn = matrix(0.0, (a, d)) lapack.gesvd(U, Stemp, jobvt='A', Vt=Vt) Un[:, :] = Vt.T[:, c:] blas.gemm(Y, Un, YUn) # compute original singular values svN = matrix(0.0, (min(a, d), 1)) lapack.gesvd(YUn, svN) # variable, [y(1);...;y(N)] # form the coefficient matrices for the nuclear norm optimization # minimize | Yh * Un |_* + alpha * | y - yh |_F AA = Hankel_basis(r, b, p=p, q=1) A = matrix(0.0, (a * d, p * N)) temp = spmatrix([], [], [], (a, b), 'd') temp2 = matrix(0.0, (a, d)) for ii in xrange(p * N): temp[:] = AA[:, ii] base.gemm(temp, Un, temp2) A[:, ii] = temp2[:] B = matrix(0.0, (a, d)) # flip the matrix if columns is more than rows if a < d: Itrans = [i + j * a for i in xrange(a) for j in xrange(d)] B[:] = B[Itrans] B.size = (d, a) for ii in xrange(p * N): A[:, ii] = A[Itrans, ii] # regularized term x0 = y[:] Qd = matrix(2.0 * svN[0] / p / N / (vsig**2), (p * N, 1)) # solve the nuclear norm optimization sol = nrmapp(A, B, C=base.spdiag(Qd), d=-base.mul(x0, Qd)) status = sol['status'] x = sol['x'] # construct YhUn and take the svd YhUn = matrix(B) blas.gemv(A, x, YhUn, beta=1.0) if a < d: YhUn = YhUn.T Uh = matrix(0.0, (a, d)) sv = matrix(0.0, (d, 1)) lapack.gesvd(YhUn, sv, jobu='S', U=Uh) # determine model order if svth is None: svth = 1E-3 svthn = sv[0] * svth n = 1 while sv[n] >= svthn and n < 10: n = n + 1 # estimate A, C Uhn = Uh[:, :n] for ii in xrange(n): blas.scal(sv[ii], Uhn, n=a, offset=ii * a) syseC = Uhn[:p, :] Als = Uhn[:-p, :] Bls = Uhn[p:, :] lapack.gels(Als, Bls) syseA = Bls[:n, :] Als[:, :] = Uhn[:-p, :] Bls[:, :] = Uhn[p:, :] blas.gemm(Als, syseA, Bls, beta=-1.0) Aerr = blas.nrm2(Bls) # stabilize A Sc = matrix(0.0, (n, n), 'z') w = matrix(0.0, (n, 1), 'z') Vs = matrix(0.0, (n, n), 'z') def F(w): return (abs(w) < 1.0) Sc[:, :] = syseA ns = lapack.gees(Sc, w, Vs, select=F) while ns < n: #print "stabilize matrix A" w[ns:] = w[ns:]**-1 Sc[::n + 1] = w Sc = Vs * Sc * Vs.H syseA[:, :] = Sc.real() Sc[:, :] = syseA ns = lapack.gees(Sc, w, Vs, select=F) # estimate B,D,x0 stored in vector [x0; vec(D); vec(B)] F1 = matrix(0.0, (p * N, n)) F1[:p, :] = syseC for ii in xrange(1, N): F1[ii * p:(ii + 1) * p, :] = F1[(ii - 1) * p:ii * p, :] * syseA F2 = matrix(0.0, (p * N, p * m)) ut = u.T for ii in xrange(p): F2[ii::p, ii::p] = ut F3 = matrix(0.0, (p * N, n * m)) F3t = matrix(0.0, (p * (N - 1), n * m)) for ii in xrange(1, N): for jj in xrange(p): for kk in xrange(n): F3t[jj:jj + (N - ii) * p:p, kk::n] = ut[:N - ii, :] * F1[(ii - 1) * p + jj, kk] F3[ii * p:, :] = F3[ii * p:, :] + F3t[:(N - ii) * p, :] F = matrix([[F1], [F2], [F3]]) yls = y[:] Sls = matrix(0.0, (F.size[1], 1)) Uls = matrix(0.0, (F.size[0], F.size[1])) Vtls = matrix(0.0, (F.size[1], F.size[1])) lapack.gesvd(F, Sls, jobu='S', jobvt='S', U=Uls, Vt=Vtls) Frank = len([ii for ii in xrange(Sls.size[0]) if Sls[ii] >= 1E-6]) #print 'Rank deficiency = ', F.size[1] - Frank xx = matrix(0.0, (F.size[1], 1)) xx[:Frank] = Uls.T[:Frank, :] * yls xx[:Frank] = base.mul(xx[:Frank], Sls[:Frank]**-1) xx[:] = Vtls.T[:, :Frank] * xx[:Frank] blas.gemv(F, xx, yls, beta=-1.0) xxerr = blas.nrm2(yls) x0 = xx[:n] syseD = xx[n:n + p * m] syseD.size = (p, m) syseB = xx[n + p * m:] syseB.size = (n, m) return {'A': syseA, 'B': syseB, 'C': syseC, 'D': syseD, 'svN': svN, 'sv': \ sv, 'x0': x0, 'n': n, 'Aerr': Aerr, 'xxerr': xxerr}
def sysid(y, u, vsig, svth = None): """ System identification using the subspace method and nuclear norm optimization. Estimate a linear time-invariant state-space model given inputs and outputs. The algorithm is described in [1]. INPUT y 'd' matrix of size (p, N). y are the measured outputs, p is the number of outputs, and N is the number of data points measured. u 'd' matrix of size (m, N). u are the inputs, m is the number of inputs, and N is the number of data points. vsig a weighting parameter in the nuclear norm optimization, its value is approximately the 1-sigma output noise level svth an optional parameter, if specified, the model order is determined as the number of singular values greater than svth times the maximum singular value. The default value is 1E-3 OUTPUT sol a dictionary with the following words -- 'A', 'B', 'C', 'D' are the state-space matrices -- 'svN', the original singular values of the Hankel matrix -- 'sv', the optimized singular values of the Hankel matrix -- 'x0', the initial state x(0) -- 'n', the model order [1] Zhang Liu and Lieven Vandenberghe. "Interior-point method for nuclear norm approximation with application to system identification." """ m, N, p = u.size[0], u.size[1], y.size[0] if y.size[1] != N: raise ValueError, "y and u must have the same length" # Y = G*X + H*U + V, Y has size a x b, U has size c x b, Un has b x d r = min(int(30/p),int((N+1.0)/(p+m+1)+1.0)) a = r*p c = r*m b = N-r+1 d = b-c # construct Hankel matrix Y Y = Hankel(y,r,b,p=p,q=1) # construct Hankel matrix U U = Hankel(u,r,b,p=m,q=1) # compute Un = null(U) and YUn = Y*Un Vt = matrix(0.0,(b,b)) Stemp = matrix(0.0,(c,1)) Un = matrix(0.0,(b,d)) YUn = matrix(0.0,(a,d)) lapack.gesvd(U,Stemp,jobvt='A',Vt=Vt) Un[:,:] = Vt.T[:,c:] blas.gemm(Y,Un,YUn) # compute original singular values svN = matrix(0.0,(min(a,d),1)) lapack.gesvd(YUn,svN) # variable, [y(1);...;y(N)] # form the coefficient matrices for the nuclear norm optimization # minimize | Yh * Un |_* + alpha * | y - yh |_F AA = Hankel_basis(r,b,p=p,q=1) A = matrix(0.0,(a*d,p*N)) temp = spmatrix([],[],[],(a,b),'d') temp2 = matrix(0.0,(a,d)) for ii in xrange(p*N): temp[:] = AA[:,ii] base.gemm(temp,Un,temp2) A[:,ii] = temp2[:] B = matrix(0.0,(a,d)) # flip the matrix if columns is more than rows if a < d: Itrans = [i+j*a for i in xrange(a) for j in xrange(d)] B[:] = B[Itrans] B.size = (d,a) for ii in xrange(p*N): A[:,ii] = A[Itrans,ii] # regularized term x0 = y[:] Qd = matrix(2.0*svN[0]/p/N/(vsig**2),(p*N,1)) # solve the nuclear norm optimization sol = nrmapp(A, B, C = base.spdiag(Qd), d = -base.mul(x0, Qd)) status = sol['status'] x = sol['x'] # construct YhUn and take the svd YhUn = matrix(B) blas.gemv(A,x,YhUn,beta=1.0) if a < d: YhUn = YhUn.T Uh = matrix(0.0,(a,d)) sv = matrix(0.0,(d,1)) lapack.gesvd(YhUn,sv,jobu='S',U=Uh) # determine model order if svth is None: svth = 1E-3 svthn = sv[0]*svth n=1 while sv[n] >= svthn and n < 10: n=n+1 # estimate A, C Uhn = Uh[:,:n] for ii in xrange(n): blas.scal(sv[ii],Uhn,n=a,offset=ii*a) syseC = Uhn[:p,:] Als = Uhn[:-p,:] Bls = Uhn[p:,:] lapack.gels(Als,Bls) syseA = Bls[:n,:] Als[:,:] = Uhn[:-p,:] Bls[:,:] = Uhn[p:,:] blas.gemm(Als,syseA,Bls,beta=-1.0) Aerr = blas.nrm2(Bls) # stabilize A Sc = matrix(0.0,(n,n),'z') w = matrix(0.0, (n,1), 'z') Vs = matrix(0.0, (n,n), 'z') def F(w): return (abs(w) < 1.0) Sc[:,:] = syseA ns = lapack.gees(Sc, w, Vs, select = F) while ns < n: #print "stabilize matrix A" w[ns:] = w[ns:]**-1 Sc[::n+1] = w Sc = Vs*Sc*Vs.H syseA[:,:] = Sc.real() Sc[:,:] = syseA ns = lapack.gees(Sc, w, Vs, select = F) # estimate B,D,x0 stored in vector [x0; vec(D); vec(B)] F1 = matrix(0.0,(p*N,n)) F1[:p,:] = syseC for ii in xrange(1,N): F1[ii*p:(ii+1)*p,:] = F1[(ii-1)*p:ii*p,:]*syseA F2 = matrix(0.0,(p*N,p*m)) ut = u.T for ii in xrange(p): F2[ii::p,ii::p] = ut F3 = matrix(0.0,(p*N,n*m)) F3t = matrix(0.0,(p*(N-1),n*m)) for ii in xrange(1,N): for jj in xrange(p): for kk in xrange(n): F3t[jj:jj+(N-ii)*p:p,kk::n] = ut[:N-ii,:]*F1[(ii-1)*p+jj,kk] F3[ii*p:,:] = F3[ii*p:,:] + F3t[:(N-ii)*p,:] F = matrix([[F1],[F2],[F3]]) yls = y[:] Sls = matrix(0.0,(F.size[1],1)) Uls = matrix(0.0,(F.size[0],F.size[1])) Vtls = matrix(0.0,(F.size[1],F.size[1])) lapack.gesvd(F, Sls, jobu='S', jobvt='S', U=Uls, Vt=Vtls) Frank=len([ii for ii in xrange(Sls.size[0]) if Sls[ii] >= 1E-6]) #print 'Rank deficiency = ', F.size[1] - Frank xx = matrix(0.0,(F.size[1],1)) xx[:Frank] = Uls.T[:Frank,:] * yls xx[:Frank] = base.mul(xx[:Frank],Sls[:Frank]**-1) xx[:] = Vtls.T[:,:Frank]*xx[:Frank] blas.gemv(F,xx,yls,beta=-1.0) xxerr = blas.nrm2(yls) x0 = xx[:n] syseD = xx[n:n+p*m] syseD.size = (p,m) syseB = xx[n+p*m:] syseB.size = (n,m) return {'A': syseA, 'B': syseB, 'C': syseC, 'D': syseD, 'svN': svN, 'sv': \ sv, 'x0': x0, 'n': n, 'Aerr': Aerr, 'xxerr': xxerr}
if a < d: p, q = d, a else: p, q = a, d x0 = y[:] S = matrix(0.0, (q,1)) # First, compute two initial points on the tradeoff curve lamT = [50.0, 0.02] nrmT = [0.0, 0.0] errT = [0.0, 0.0] for i in xrange(len(lamT)): Cd = matrix(2.0*lamT[i], (n,1)) C = base.spdiag(Cd) d = -base.mul(Cd, x0) sol = nucnrm.nrmapp(A, B, C = C, d = d) x = sol['x'] lapack.gesvd(matrix(A*x, (p,q)) + B, S) nrmT[i] = sum(S) errT[i] = blas.dot(x-x0, x-x0) # plot the tradeoff curve upper/lower bounds with the initial 2 points pylab.figure(0) N = 200 slope = -matrix(lamT) errM = matrix(errT) nrmM = matrix(nrmT)
if a < d: p, q = d, a else: p, q = a, d x0 = y[:] S = matrix(0.0, (q, 1)) # First, compute two initial points on the tradeoff curve lamT = [50.0, 0.02] nrmT = [0.0, 0.0] errT = [0.0, 0.0] for i in xrange(len(lamT)): Cd = matrix(2.0 * lamT[i], (n, 1)) C = base.spdiag(Cd) d = -base.mul(Cd, x0) sol = nucnrm.nrmapp(A, B, C=C, d=d) x = sol['x'] lapack.gesvd(matrix(A * x, (p, q)) + B, S) nrmT[i] = sum(S) errT[i] = blas.dot(x - x0, x - x0) # plot the tradeoff curve upper/lower bounds with the initial 2 points pylab.figure(0) N = 200 slope = -matrix(lamT) errM = matrix(errT) nrmM = matrix(nrmT)
def what_is_the_matrix(X, Z): """find the optimal morphing matrix A such that A * src_dist = target_dist""" #print "============ What is the Matrix? ===============" n = len(Z) N = n**2 #print "X =", X.T #print "Z =", Z.T # Equality Constraints A_list = [] b_list = [] # -- the columns of the matrix must be valid PDF's A_pdf = matrix(0.0, (n,N), 'd') for i in range(n): A_pdf[i,n*i:n*i+n] = 1.0 b_pdf = matrix(1.0, (n,1), 'd') #print "A_pdf =" #print A_pdf #print "b_pdf =" #print b_pdf A_list.append(A_pdf) b_list.append(b_pdf) # -- the matrix must morph X to Z A_morph = matrix(0.0, (n,N), 'd') for i in range(n): matrix_vers = matrix(0.0, (n,n), 'd') matrix_vers[i,:] = X.T row = matrix(matrix_vers, (1,N), 'd') A_morph[i,:] = row b_morph = matrix(Z, (n,1), 'd') A_list.append(A_morph) b_list.append(b_morph) #print "A_morph =" #print A_morph #print "b_morph =" #print b_morph # concatenate all our equality constraints into one coeff matrix and one b vector #A_list = [A_morph, A_pdf] #b_list = [b_morph, b_pdf] #A_list = [A_pdf] #b_list = [b_pdf] #A = matrix(A_list) A = sparse(A_list) b = matrix(b_list) #print "A =" #print A #print "b =" #print b # Inequality Constraints -- in order to be a valid PDF, each cell a_ij must be 0 <= a_ij <= 1 G_list = [] h_list = [] G_lt = spdiag(matrix(1.0, (N,1), 'd')) h_lt = matrix(1.0, (N,1), 'd') # cvw: as mentioned in the comment above in find_the_one(), the "less than" constraints are # in fact redundant given that we already require the columns to sum to 1.0 and require # (below) that each prob is >= 0. yay for smaller KKT matrices. #G_list.append(G_lt) #h_list.append(h_lt) G_gt = spdiag(matrix(-1.0, (N,1), 'd')) h_gt = matrix(0.0, (N,1), 'd') G_list.append(G_gt) h_list.append(h_gt) # cvw: I guess we could add some more constraints if we really wanted to.. # i.e. only downgrade the bit rate 10% of the time or less # but for now these'll do G = sparse(G_list) h = matrix(h_list) #print "G =" #print G #print "h =" #print h #print "vectorized cost matrix =" #print c.T # now run the cvxopt solver to get our answer #print "running cvxopt lp() solver..." ans = solvers.lp(cost_matrix, G=G, h=h, A=A, b=b, solver='glpk') ##print ans['x'] #print "answer = ", ans A = None if ans['x']: cost = cost_matrix.T * ans['x'] # A is the morphing matrix A = matrix(ans['x'], (n,n), 'd') return A
def findpos(a, b, r, bounds=None, float_r=True): alpha = 10.0 # preference for moving circles over shrinking them beta = 100 # Every circle would ideally be 100 pixels larger small = 0.01 # Initial radius for float_r # P and q represent the energy function, distance from (a,b), that we are # trying to minimize N = len(a) n = 2 * N pos = [] pos.extend(a) pos.extend(b) if float_r: pos.extend(r) ideals = matrix(pos, tc='d') q = -ideals init = ideals if float_r: q[2*N:3*N] -= beta q[2*N:3*N] *= alpha init[2*N:3*N] = small if float_r: n = 3 * N ones = matrix(1, (1, n), tc='d') if float_r: ones[2*N:3*N] = alpha P = spdiag(ones) x = [] I = [] J = [] hlist = [] # x, I, and J, are the sparse coordinates for building G # G and h provide all the constraints # this loop adds the constraint that the projection of (the vector # between any two centers) onto (the vector connecting their ideal locations) # must not be shorter than the sum of their radii c = 0 for i in xrange(N): for j in xrange(i+1, N): dx = a[i]-a[j] dy = b[i]-b[j] d = sqrt(dx*dx + dy*dy) x.append(-dx) I.append(c) J.append(i) x.append(dx) I.append(c) J.append(j) x.append(-dy) I.append(c) J.append(i + N) x.append(dy) I.append(c) J.append(j + N) if float_r: x.append(d) I.append(c) J.append(i + 2*N) x.append(d) I.append(c) J.append(j + 2*N) hlist.append(0) else: hlist.append(-d*(r[i] + r[j])) c += 1 if float_r: # Place upper and lower bounds on each radius for i in xrange(N): x.append(1) I.append(c) J.append(i + 2*N) hlist.append(r[i]) c += 1 x.append(-1) I.append(c) J.append(i + 2*N) hlist.append(0) c += 1 if bounds is not None: lbx = bounds[0] ubx = bounds[1] lby = bounds[2] uby = bounds[3] for i in xrange(N): x.append(-1) I.append(c) J.append(i) x.append(1) I.append(c) J.append(i + 2*N) hlist.append(-lbx) c += 1 x.append(1) I.append(c) J.append(i) x.append(1) I.append(c) J.append(i + 2*N) hlist.append(ubx) c += 1 x.append(-1) I.append(c) J.append(i + N) x.append(1) I.append(c) J.append(i + 2*N) hlist.append(-lby) c += 1 x.append(1) I.append(c) J.append(i + N) x.append(1) I.append(c) J.append(i + 2*N) hlist.append(uby) c += 1 else: if bounds is not None: lbx = bounds[0] ubx = bounds[1] lby = bounds[2] uby = bounds[3] for i in xrange(N): x.append(-1) I.append(c) J.append(i) hlist.append(-r[i]-lbx) c += 1 x.append(1) I.append(c) J.append(i) hlist.append(ubx-r[i]) c += 1 x.append(-1) I.append(c) J.append(i + N) hlist.append(-r[i]-lby) c += 1 x.append(1) I.append(c) J.append(i + N) hlist.append(uby-r[i]) c += 1 G = spmatrix(x, I, J) h = matrix(hlist, tc='d') #this line actually solves the problem initvals = {} initvals['x'] = init #print init if float_r: initvals['s'] = h - G*init #print initvals['s'] initvals['y'] = matrix(1, (0,1), tc='d') # z is actually supposed to satisfy Px + G*s + Ay + c = 0, so this definition # is extremely far from correct #initvals['z'] = 0 * h outdict = qp(P, q, G, h, initvals=initvals) #print outdict if outdict['status'] == 'optimal': bestpos = outdict['x'] #print bestpos - ideals bestx = bestpos[:N] besty = bestpos[N:2*N] if float_r: bestr = bestpos[2*N:3*N] else: bestr = r return (list(bestx), list(besty), list(bestr)) else: return None
def solve_phase1(self,kktsolver='chol',MM = 1e5): """ Solves primal Phase I problem using the feasible start solver. Returns primal feasible X. """ from cvxopt import cholmod, amd k = 1e-3 # compute Schur complement matrix Id = [i*(self.n+1) for i in range(self.n)] As = self._A[:,1:] As[Id,:] /= sqrt(2.0) M = spmatrix([],[],[],(self.m,self.m)) base.syrk(As,M,trans='T') u = +self.b # compute least-norm solution F = cholmod.symbolic(M) cholmod.numeric(M,F) cholmod.solve(F,u) x = 0.5*self._A[:,1:]*u X0 = spmatrix(x[self.V[:].I],self.V.I,self.V.J,(self.n,self.n)) # test feasibility p = amd.order(self.V) #Xc,Nf = chompack.embed(X0,p) #E = chompack.project(Xc,spmatrix(1.0,range(self.n),range(self.n))) symb = chompack.symbolic(self.V,p) Xc = chompack.cspmatrix(symb) + X0 try: # L = chompack.completion(Xc) L = Xc.copy() chompack.completion(L) # least-norm solution is feasible return X0,None except: pass # create Phase I SDP object trA = matrix(0.0,(self.m+1,1)) e = matrix(1.0,(self.n,1)) Aa = self._A[Id,1:] base.gemv(Aa,e,trA,trans='T') trA[-1] = MM P1 = SDP() P1._A = misc.phase1_sdp(self._A,trA) P1._b = matrix([self.b-k*trA[:self.m],MM]) P1._agg_sparsity() # find feasible starting point for Phase I problem tMIN = 0.0 tMAX = 1.0 while True: t = (tMIN+tMAX)/2.0 #Xt = chompack.copy(Xc) #chompack.axpy(E,Xt,t) Xt = Xc.copy() + spmatrix(t,list(range(self.n)),list(range(self.n))) try: # L = chompack.completion(Xt) L = Xt.copy() chompack.completion(L) tMAX = t if tMAX - tMIN < 1e-1: break except: tMAX *= 2.0 tMIN = t tt = t + 1.0 U = X0 + spmatrix(tt,list(range(self.n,)),list(range(self.n))) trU = sum(U[:][Id]) Z0 = spdiag([U,spmatrix([tt+k,MM-trU],[0,1],[0,1],(2,2))]) sol = P1.solve_feas(primalstart = {'x':Z0}, kktsolver = kktsolver) s = sol['x'][-2,-2] - k if s > 0: return None,P1 else: sol.pop('y') sol.pop('s') X0 = sol.pop('x')[:self.n,:self.n]\ - spmatrix(s,list(range(self.n)),list(range(self.n))) return X0,sol
def solve_phase1(self, kktsolver='chol', MM=1e5): """ Solves primal Phase I problem using the feasible start solver. Returns primal feasible X. """ from cvxopt import cholmod, amd k = 1e-3 # compute Schur complement matrix Id = [i * (self.n + 1) for i in range(self.n)] As = self._A[:, 1:] As[Id, :] /= sqrt(2.0) M = spmatrix([], [], [], (self.m, self.m)) base.syrk(As, M, trans='T') u = +self.b # compute least-norm solution F = cholmod.symbolic(M) cholmod.numeric(M, F) cholmod.solve(F, u) x = 0.5 * self._A[:, 1:] * u X0 = spmatrix(x[self.V[:].I], self.V.I, self.V.J, (self.n, self.n)) # test feasibility p = amd.order(self.V) #Xc,Nf = chompack.embed(X0,p) #E = chompack.project(Xc,spmatrix(1.0,range(self.n),range(self.n))) symb = chompack.symbolic(self.V, p) Xc = chompack.cspmatrix(symb) + X0 try: # L = chompack.completion(Xc) L = Xc.copy() chompack.completion(L) # least-norm solution is feasible return X0 except: pass # create Phase I SDP object trA = matrix(0.0, (self.m + 1, 1)) e = matrix(1.0, (self.n, 1)) Aa = self._A[Id, 1:] base.gemv(Aa, e, trA, trans='T') trA[-1] = MM P1 = SDP() P1._A = misc.phase1_sdp(self._A, trA) P1._b = matrix([self.b - k * trA[:self.m], MM]) P1._agg_sparsity() # find feasible starting point for Phase I problem tMIN = 0.0 tMAX = 1.0 while True: t = (tMIN + tMAX) / 2.0 #Xt = chompack.copy(Xc) #chompack.axpy(E,Xt,t) Xt = Xc.copy() + spmatrix(t, range(self.n), range(self.n)) try: # L = chompack.completion(Xt) L = Xt.copy() chompack.completion(L) tMAX = t if tMAX - tMIN < 1e-1: break except: tMAX *= 2.0 tMIN = t tt = t + 1.0 U = X0 + spmatrix(tt, range(self.n, ), range(self.n)) trU = sum(U[:][Id]) Z0 = spdiag([U, spmatrix([tt + k, MM - trU], [0, 1], [0, 1], (2, 2))]) sol = P1.solve_feas(primalstart={'x': Z0}, kktsolver=kktsolver) s = sol['x'][-2, -2] - k if s > 0: return None, P1 else: sol.pop('y') sol.pop('s') X0 = sol.pop('x')[:self.n,:self.n]\ - spmatrix(s,range(self.n),range(self.n)) return X0, sol
random.normalvariate(0.5, 1), 1.0) for i in range(5)] classB = [(random.normalvariate(0.0, 0.5), random.normalvariate(-0.5, 0.5), -1.0) for i in range(10)] data = classA + classB random.shuffle(data) # Build P,q,h and G P = buildP(data) N = 20 q = matrix(-1.0, (N, 1)) # Vector of size N containing only -1 G = matrix(spdiag( N * [-1.0])) # Diagonal matrix with -1 on the diagonal, 0 otherwise h = matrix(0.0, (N, 1)) # Vector of size N containing only 0 # QP Optimizer r = qp(matrix(P), matrix(q), matrix(G), matrix(h)) alpha = list(r['x']) # Get support vectors sv = getSupportVectors(alpha) # Plot data pylab.hold(True) pylab.plot([p[0] for p in classA], [p[1] for p in classA], 'bo') pylab.plot([p[0] for p in classB], [p[1] for p in classB], 'ro') # Plot boundaries