def get_weights(self) -> pd.Series: assets_number = self.cov_matrix.shape[1] st_devs = self.std_of_assets.values st_devs = st_devs.reshape((1, -1)) # make it a horizontal vector P = matrix(self.cov_matrix.values) q = matrix(0.0, (assets_number, 1)) A = matrix(st_devs) b = matrix([1.0]) G_lower_bound, h_lower_bound = each_weight_greater_than_0_constraint( assets_number) if self.upper_constraint is not None: G_upper_bound, h_upper_bound = self._get_upper_bound_constraints( P, q, G_lower_bound, h_lower_bound, A, b) G, h = merge_constraints(G_lower_bound, h_lower_bound, G_upper_bound, h_upper_bound) else: G, h = G_lower_bound, h_lower_bound result = qp(P, q, G, h, A, b, options=self.optimizer_options) dummy_weights = np.array(result['x']).squeeze() scaled_weights = dummy_weights / dummy_weights.sum() weights_series = pd.Series(data=scaled_weights, index=self.cov_matrix.columns.values) return weights_series
def __init__(self): base_device.__init__(self) self.u = mul(matrix(self.u), matrix(system.PV.u)) self._data.update({ 'bus': None, 'Type': 1, 'vrmax': 3.3, 'vrmin': -2.6, 'K0': 0, 'T1': 0, 'T2': 0, 'T3': 0, 'T4': 0, 'Te': 0, 'Tr': 0, 'Ae': 0, 'Be': 0 }) self._type = 'Avr1' self._name = 'Avr1' self._bus = {'bus': ['a', 'v']} self._algebs = ['vref'] # 后续得修改 self._states = ['vm', 'vr1', 'vr2', 'vf'] # 后续得修改 self._params.extend([ 'u', 'vrmax', 'vrmin', 'K0', 'T1', 'T2', 'T3', 'T4', 'Te', 'Tr', 'Ae', 'Be' ]) self._voltages = ['V0'] # 后续得修改 self._powers = ['Pg'] # 后续得修改 self.ba = [] self.bv = []
def solve_only_equalities_qp(kktsolver, fP, fA, resx0, resy0, dims): # Solve # # [ P A' ] [ x ] [ -q ] # [ ] [ ] = [ ]. # [ A 0 ] [ y ] [ b ] # print(G) # factor = kkt_chol2(G, dims, A) # W = {'d': matrix(0.0, (0, 1)), 'di': matrix(0.0, (0, 1)), 'beta': [], 'v': [], 'r': [], 'rti': []} # print(P) # solver = factor(W, P) try: f3 = kktsolver({'d': matrix(0.0, (0, 1)), 'di': matrix(0.0, (0, 1)), 'beta': [], 'v': [], 'r': [], 'rti': []}) # factor = kkt_chol2(G, dims, A) # W = {'d': matrix(0.0, (0, 1)), 'di': matrix(0.0, (0, 1)), 'beta': [], 'v': [], 'r': [], 'rti': []} # f3 = factor(W, P) except ArithmeticError: raise ValueError("Rank(A) < p or Rank([P; A; G]) < n") x = -1.0 * matrix(q) y = matrix(b) f3(x, y, matrix(0.0, (0, 1))) # solver(x, y, matrix(0.0, (0, 1))) return {'status': 'optimal', 'x': x, 'y': y}
def read(dataset = "training", path = "."): """ Python function for importing the MNIST data set. """ digits = [1,2,3,4,5,6,7,8,9,0] if dataset is "training": fname_img = os.path.join(path, 'train-images-idx3-ubyte') fname_lbl = os.path.join(path, 'train-labels-idx1-ubyte') elif dataset is "testing": fname_img = os.path.join(path, 't10k-images-idx3-ubyte') fname_lbl = os.path.join(path, 't10k-labels-idx1-ubyte') else: raise ValueError, "dataset must be 'testing' or 'training'" flbl = open(fname_lbl, 'rb') magic_nr, size = struct.unpack(">II", flbl.read(8)) lbl = array("b", flbl.read()) flbl.close() fimg = open(fname_img, 'rb') magic_nr, size, rows, cols = struct.unpack(">IIII", fimg.read(16)) img = array("B", fimg.read()) fimg.close() ind = [ k for k in xrange(size) if lbl[k] in digits ] images = matrix(0, (len(ind), rows*cols)) labels = matrix(0, (len(ind), 1)) for i in xrange(len(ind)): images[i, :] = img[ ind[i]*rows*cols : (ind[i]+1)*rows*cols ] labels[i] = lbl[ind[i]] return images, labels
def classifier2(Y, soft=False): M = Y.size[0] # K = Y*X' / sigma K = matrix(theta, (width, M)) blas.gemm(X, Y, K, transB='T', alpha=1.0 / sigma, beta=-1.0, m=width) K = exp(K) K = div(K - K**-1, K + K**-1) # complete K lapack.potrs(L11, K) K = matrix([K, matrix(0., (N - width, M))], (N, M)) chompack.trsm(Lc, K, trans='N') chompack.trsm(Lc, K, trans='T') x = matrix(b, (M, 1)) blas.gemv(K, z, x, trans='T', beta=1.0) if soft: return x else: return matrix([2 * (xk > 0.0) - 1 for xk in x])
def numerical_hessian(x_k, f_k, func, epsilon, *args): n_params, one = x_k.size assert one==1 H = cvx.matrix(0.0, (n_params,n_params)) epsilon2 = epsilon**2 ei = cvx.matrix(0.0, x_k.size) esame = cvx.matrix(0.0, x_k.size) ecross = cvx.matrix(0.0, x_k.size) for i in range(n_params): esame[i], ecross[i] = +epsilon, +epsilon for j in range(i): esame[j], ecross[j] = +epsilon, -epsilon lhs = func(x_k+esame, *args) - func(x_k+ecross, *args) rhs = func(x_k-ecross, *args) - func(x_k-esame, *args) H[i,j] = (lhs - rhs) / (4*epsilon2) H[j,i] = H[i,j] esame[j], ecross[j] = 0.0, 0.0 esame[i], ecross[i] = 0.0, 0.0 ei[i] = epsilon H[i,i] = (func(x_k+ei, *args) + func(x_k-ei, *args) - 2*f_k) / epsilon2 ei[i] = 0.0 return H
def calc_alpha(data,kernel,threshold,p=1): size = len(data) P = matrix(P_matrix(data,kernel,p)) q = matrix(q_vector(size)) G = matrix(G_matrix(size)) h = matrix(h_vector(size)) return [[data[i],a] for i,a in enumerate(list(qp(P,q,G,h)['x'])) if a>threshold]
def write_sdpa(self, fname=None, compress=False): """Writes problem data to sparse SDPA data file""" import bz2 if not self._blockstruct: self._blockstruct = matrix(self.n, (1, 1)) if fname is None: fname = self._pname fname += ".dat-s" if compress: if not os.path.isfile(fname) and not os.path.isfile(fname + ".bz2"): f = open(fname, 'w') elif os.path.isfile(fname): raise IOError, "file %s already exists" % (fname) else: raise IOError, "file %s already exists" % (fname + ".bz2") elif not os.path.isfile(fname): f = open(fname, 'w') else: raise IOError, "file %s already exists" % (fname) misc.sdpa_write(f, self._A, matrix(self._b), self._blockstruct, neg=True) f.close() if compress: f = open(fname + ".bz2", 'wb') f.write(bz2.compress(open(fname).read())) f.close() os.remove(fname)
def read(digits, path = "./../../data/", data="alphabets-font-images.idx", label="alphabets-font-labels.idx", ignoreList = []): """ Python function for importing the MNIST data set. """ fname_img = os.path.join(path, data)#'alphabets-font-images.idx') fname_lbl = os.path.join(path, label)#'alphabets-font-labels.idx') flbl = open(fname_lbl, 'rb') magic_nr, size = struct.unpack(">II", flbl.read(8)) lbl = array("b", flbl.read()) flbl.close() fimg = open(fname_img, 'rb') magic_nr, size, rows, cols = struct.unpack(">IIII", fimg.read(16)) img = array("B", fimg.read()) fimg.close() #print '(^_^)' #print 'ignoreList='+str(ignoreList) #print ('----') ind = [ k for k in xrange(size) if ((not lbl[k] in ignoreList) and (lbl[k] in digits or digits == [])) ] images = matrix(0, (len(ind), rows*cols)) labels = matrix(0, (len(ind), 1)) for i in xrange(len(ind)): images[i, :] = img[ ind[i]*rows*cols : (ind[i]+1)*rows*cols ] labels[i] = lbl[ind[i]] return images, labels
def main(): data = generateData() q = numpy.empty((DATAPOINTS,1)) q[:] = -1.0 h = numpy.empty((DATAPOINTS,1)) h[:] = 0.0 G = numpy.empty((DATAPOINTS,DATAPOINTS)) numpy.fill_diagonal(G, -1) P = createP(data) r = qp(matrix(P),matrix(q),matrix(G),matrix(h)) alpha = list(r['x']) xrange = numpy.arange(-4, 4, 0.05) yrange = numpy.arange(-4, 4, 0.05) support = getSupportVectors(alpha, data) grid = matrix([[indicator(x,y,support) for y in yrange] for x in xrange]) pylab.contour(xrange, yrange, grid, (-1.0, 0.0, 1.0), colors=('red', 'black', 'blue'), linewidths=(1, 1, 1)) pylab.show()
def read(digits, path = "./../../data/"): """ Python function for importing the MNIST data set. """ fname_img = os.path.join(path, 'img.idx') fname_lbl = os.path.join(path, 'label.idx') flbl = open(fname_lbl, 'rb') magic_nr, size = struct.unpack(">II", flbl.read(8)) lbl = array("b", flbl.read()) flbl.close() fimg = open(fname_img, 'rb') magic_nr, size, rows, cols = struct.unpack(">IIII", fimg.read(16)) img = array("B", fimg.read()) fimg.close() ind = [ k for k in xrange(size) if (lbl[k] in digits) ] images = matrix(0, (len(ind), rows*cols)) labels = matrix(0, (len(ind), 1)) for i in xrange(len(ind)): images[i, :] = img[ ind[i]*rows*cols : (ind[i]+1)*rows*cols ] labels[i] = lbl[ind[i]] return images, labels
def QuadOpt(x, P, slack, C): # intialize parameters # slack variable introduced if slack == 1: h = np.row_stack((np.zeros((len(x), 1)), C * np.ones((len(x), 1)))) G = np.row_stack((np.diag([-1.0] * len(x)), np.diag([1.0] * len(x)))) else: h = np.zeros((len(x), 1)) G = np.diag([-1.0] * len(x)) q = -1 * np.ones((len(x), 1)) # call qp r = qp(matrix(P), matrix(q), matrix(G), matrix(h)) alpha = list(r['x']) # pick out non-zero alpha # slack variable introduced support = list() for i in range(len(alpha)): if slack == 1: if (alpha[i] > 10e-5) and (alpha[i] < C): support.append((x[i][0], x[i][1], x[i][2], alpha[i])) else: if alpha[i] > 10e-5: support.append((x[i][0], x[i][1], x[i][2], alpha[i])) return support
def numerical_hessian(x_k, f_k, func, epsilon, *args): n_params, one = x_k.size assert one == 1 H = cvx.matrix(0.0, (n_params, n_params)) epsilon2 = epsilon**2 ei = cvx.matrix(0.0, x_k.size) esame = cvx.matrix(0.0, x_k.size) ecross = cvx.matrix(0.0, x_k.size) for i in range(n_params): esame[i], ecross[i] = +epsilon, +epsilon for j in range(i): esame[j], ecross[j] = +epsilon, -epsilon lhs = func(x_k + esame, *args) - func(x_k + ecross, *args) rhs = func(x_k - ecross, *args) - func(x_k - esame, *args) H[i, j] = (lhs - rhs) / (4 * epsilon2) H[j, i] = H[i, j] esame[j], ecross[j] = 0.0, 0.0 esame[i], ecross[i] = 0.0, 0.0 ei[i] = epsilon H[i, i] = (func(x_k + ei, *args) + func(x_k - ei, *args) - 2 * f_k) / epsilon2 ei[i] = 0.0 return H
def findSplittingPlane(self,Mid, data,show_contour, C=-1): # having a default value on C is horrible but im to lazy to make it neat for such a small program P_Matrix = [[0.0 for x in range(len(data))] for x in range(len(data))] # build p P_matrix for idi, i in enumerate(data): for idj, j in enumerate(data): # if i==j: is diagonal a special case? # continue P_Matrix[idi][idj] = self.getPelem(i,j,self.kernel) if(PRINT_P_MATRIX): self.printTwoDimensional(P_Matrix) # Build vectors for qp q_vec = [-1.0 for x in range(len(data))] h_vec = [0.0 for x in range(len(data))] G_Matrix = [[ -1.0 if x==y else 0.0 for y in range(len(data))] for x in range(len(data))] # call qp r = qp(matrix(P_Matrix), matrix(q_vec), matrix(G_Matrix), matrix(h_vec)) alpha = list(r['x']) alphaValues =[] # pick out the non zero alpha values for idx,elem in enumerate(alpha): if(elem > pow(10,-5)): if( C!=-1 and elem <= C): continue data[idx].alpha = elem alphaValues.append(data[idx]) # implemnt the indication function xrange = numpy.arange(-4,4,0.05) yrange = numpy.arange(-4,4,0.05) grid=matrix([[self.indicator(x,y, alphaValues) for y in yrange] for x in xrange]) if(PLOT_OUPUT): self.plotData(Mid, data,xrange,yrange,grid, show_contour)
def _gen_bandsdp(self,n,m,bw,seed): """Random data generator for SDP with band structure""" setseed(seed) I = matrix([ i for j in range(n) for i in range(j,min(j+bw+1,n))]) J = matrix([ j for j in range(n) for i in range(j,min(j+bw+1,n))]) V = spmatrix(0.,I,J,(n,n)) Il = misc.sub2ind((n,n),I,J) Id = matrix([i for i in range(len(Il)) if I[i]==J[i]]) # generate random y with norm 1 y0 = normal(m,1) y0 /= blas.nrm2(y0) # generate random S0 S0 = mk_rand(V,cone='posdef',seed=seed) X0 = mk_rand(V,cone='completable',seed=seed) # generate random A1,...,Am and set A0 = sum Ai*yi + S0 A_ = normal(len(I),m+1,std=1./len(I)) u = +S0.V blas.gemv(A_[:,1:],y0,u,beta=1.0) A_[:,0] = u # compute b x = +X0.V x[Id] *= 0.5 self._b = matrix(0.,(m,1)) blas.gemv(A_[:,1:],x,self._b,trans='T',alpha=2.0) # form A self._A = spmatrix(A_[:], [i for j in range(m+1) for i in Il], [j for j in range(m+1) for i in Il],(n**2,m+1)) self._X0 = X0; self._y0 = y0; self._S0 = S0
def solve_cvxopt(self,primalstart=None,dualstart=None,\ options=None,kktsolver=None): """ Passes problem data to CVXOPT sdp solver. ARGUMENTS RETURNS sol Dictionary """ from cvxopt import solvers if options: for key in list(options.keys()): solvers.options[key] = options[key] if primalstart: y0,S0 = dualstart['y'],dualstart['s'] PS = {'x':y0,'s':[matrix(S0[:])]} else: PS = None if dualstart: X0 = primalstart['x'] DS = {'y':None,'zl':[matrix(X0[:])]} else: DS = None return solvers.conelp(c = -self._b, G = self._A[:,1:], h = matrix(self.get_A(0)[:]), dims = {'l':0,'q':[],'s':[self.n]}, primalstart = PS, dualstart = DS, kktsolver = kktsolver)
def intervention(self, t): # for item in range(system.Line.n): if t == self.tf[item]: #发生故障 print('线路%i在t = %s s断开' % (item+1, self.tf[item])) #启用故障 system.Line.u[item] = 0 #存储故障前 self._ang = matrix(system.DAE.y[system.Bus.a]) self._vol = matrix(system.DAE.y[system.Bus.n:len(system.DAE.y)]) if t == self.tc[item]: #故障清除 print('线路%i在t = %s s恢复连接' % (item+1, self.tc[item])) # 禁用故障 system.Line.u[item] = 1 #恢复电压 if system.Settings.resetangles: system.DAE.y[system.Bus.a] = matrix(self._ang) system.DAE.y[system.Bus.n:len(system.DAE.y)] = matrix(self._vol) system.Line.build_y()
def CVXOPT_LP_Solver(p, solverName): #os.close(1); os.close(2) if solverName == 'native_CVXOPT_LP_Solver': solverName = None cvxopt_solvers.options['maxiters'] = p.maxIter cvxopt_solvers.options['feastol'] = p.contol cvxopt_solvers.options['abstol'] = p.ftol if p.iprint <= 0: cvxopt_solvers.options['show_progress'] = False cvxopt_solvers.options['LPX_K_MSGLEV'] = 0 cvxopt_solvers.options['MSK_IPAR_LOG'] = 0 xBounds2Matrix(p) #WholeRepr2LinConst(p) # CVXOPT have some problems with x0 so currently I decided to avoid using the one #if p.x0.size>0 and p.x0.flatten()[0] != None and all(isfinite(p.x0)): # sol= cvxopt_solvers.solvers.lp(Matrix(p.f), Matrix(p.A), Matrix(p.b), Matrix(p.Aeq), Matrix(p.beq), solverName) #else: if (len(p.intVars)>0 or len(p.binVars)>0) and solverName == 'glpk': from cvxopt.glpk import ilp c = Matrix(p.f) A, b = Matrix(p.Aeq), Matrix(p.beq) G, h = Matrix(p.A), Matrix(p.b) if A is None: A = matrix(0.0, (0, p.n)) b = matrix(0.0,(0,1)) if G is None: G = matrix(0.0, (0, p.n)) h = matrix(0.0,(0,1)) (status, x) = ilp(c, G, h, A, b, set(p.intVars), B=set(p.binVars)) if status == 'optimal': p.istop = SOLVED_WITH_UNIMPLEMENTED_OR_UNKNOWN_REASON elif status == 'maxiters exceeded': p.istop = IS_MAX_ITER_REACHED elif status == 'time limit exceeded': p.istop = IS_MAX_TIME_REACHED elif status == 'unknown': p.istop = UNDEFINED else: p.istop = FAILED_WITH_UNIMPLEMENTED_OR_UNKNOWN_REASON if x is None: p.xf = nan*ones(p.n) else: p.xf = array(x).flatten()#w/o flatten it yields incorrect result in ff! p.ff = sum(p.dotmult(p.f, p.xf)) p.msg = status else: # if len(p.b) != 0: # s0 = matrix(p.b - dot(p.A, p.x0)) # else: # s0 = matrix() # primalstart = {'x': matrix(p.x0), 's': s0} # sol = cvxopt_solvers.lp(Matrix(p.f), Matrix(p.A), Matrix(p.b), Matrix(p.Aeq), Matrix(p.beq), solverName, primalstart) sol = cvxopt_solvers.lp(Matrix(p.f), Matrix(p.A), Matrix(p.b), Matrix(p.Aeq), Matrix(p.beq), solverName) p.msg = sol['status'] if p.msg == 'optimal' : p.istop = SOLVED_WITH_UNIMPLEMENTED_OR_UNKNOWN_REASON else: p.istop = -100 if sol['x'] is not None: p.xf = asarray(sol['x']).flatten() # ! don't involve p.ff - it can be different because of goal and additional constant from FuncDesigner p.duals = concatenate((asarray(sol['y']).flatten(), asarray(sol['z']).flatten())) else: p.ff = nan p.xf = nan*ones(p.n)
def read(digits, dataset="training", path="."): """ Python function for importing the MNIST data set. """ #print("dataset is ",dataset) if dataset is "training": fname_img = os.path.join(path, '\\train-images-idx3-ubyte') fname_lbl = os.path.join(path, '\\train-labels-idx1-ubyte') elif dataset is "testing": fname_img = os.path.join(path, '\\t10k-images-idx3-ubyte') fname_lbl = os.path.join(path, '\\t10k-labels-idx1-ubyte') else: raise ValueError("dataset must be 'testing' or 'training'") flbl = open(fname_lbl, 'rb') magic_nr, size = struct.unpack(">II", flbl.read(8)) lbl = array("b", flbl.read()) flbl.close() fimg = open(fname_img, 'rb') magic_nr, size, rows, cols = struct.unpack(">IIII", fimg.read(16)) img = array("B", fimg.read()) fimg.close() ind = [k for k in range(size) if lbl[k] in digits] images = matrix(0, (len(ind), rows * cols)) labels = matrix(0, (len(ind), 1)) for i in range(len(ind)): images[i, :] = img[ind[i] * rows * cols:(ind[i] + 1) * rows * cols] labels[i] = lbl[ind[i]] return images, labels
def read_mps_preprocess(filepath): problem = op() problem.fromfile(filepath) mat_form = problem._inmatrixform(format='dense') format = 'dense' assert mat_form lp, vmap, mmap = mat_form variables = lp.variables() x = variables[0] c = lp.objective._linear._coeff[x] inequalities = lp._inequalities G = inequalities[0]._f._linear._coeff[x] h = -inequalities[0]._f._constant equalities = lp._equalities A, b = None, None if equalities: A = equalities[0]._f._linear._coeff[x] b = -equalities[0]._f._constant elif format == 'dense': A = matrix(0.0, (0, len(x))) b = matrix(0.0, (0, 1)) else: A = spmatrix(0.0, [], [], (0, len(x))) # CRITICAL b = matrix(0.0, (0, 1)) c = np.array(c).flatten() G = np.array(G) h = np.array(h).flatten() A = np.array(A) b = np.array(b).flatten() return c, G, h, A, b
def gcall(self): if self.n == 0: return slip = system.DAE.x[self.slip] V = mul(self.u, system.DAE.y[self.v]) # 后续得修改 t = system.DAE.y[self.a] st = sin(t) ct = cos(t) Vr = mul(V, st) Vm = mul(V, ct) e1r = system.DAE.x[self.e1r] e1m = system.DAE.x[self.e1m] a03 = mul(self.rs, self.rs) + mul(self.x1, self.x1) a13 = div(self.rs, a03) a23 = div(self.x1, a03) a33 = self.x0 - self.x1 Im = mul(-a23, -Vr - e1r + mul(a13, (Vm - e1m))) Ir = mul(a13, -Vr - e1r) + mul(a23, Vm - e1m) system.DAE.g = system.DAE.g \ + spmatrix(mul(-Vr, Ir)+mul(Vm, Im), self.a, matrix(0, (self.n, 1)), (system.DAE.ny, 1)) \ + spmatrix(mul(Vr, Im) + mul(Vm, Ir), self.v, matrix(0, (self.n, 1)), (system.DAE.ny, 1))
def __init__(self): self.g = [] # 代数方程 self.f = [] # 微分方程 self.y = [] # 代数变量 self.x = [] # 状态变量 self.Y = matrix() # 导纳矩阵 self.Y_G = matrix() # 导纳矩阵实部 self.Y_B = matrix() # 导纳矩阵虚部 self.Gy = [] # 代数方程的雅可比矩阵 self.Fx = [] self.Fy = [] self.Gx = [] self.nx = 0 # 状态变量个数 self.ny = 0 # 代数变量个数,默认为0 self.n_bus = 0 # 母线节点数,默认为0 self.t = [] self.factorize = [] # 如果是True,则对雅可比矩阵进行因式分解 self._params = [ 'g', 'x', 'y', 'f', 'Fx', 'Fy', 'Gx', 'Y', 'Y_G', 'Y_B', 'Gy' ] self.factorize = True # 如果是True,则对雅可比矩阵进行因式分解 self.tn = [] # 时域仿真的微分方程 self.Ac = [] # 时域仿真雅可比方程
def solve(self): c_ = matrix(self.c) # adding the dummy constraint A_ = np.vstack((self.A, -self.c)) b_ = np.hstack((self.b, [1.0])) G = matrix(A_) h = matrix(b_) self.result = solvers.lp(c_, G, h, solver=solver) primal_objective_ = self.result['primal objective'] status_ = self.result['status'] if primal_objective_ < -0.5: logger.warning('cvxopt status={} with dummy'.format(status_)) self.status = UNBOUNDED else: logger.warning('cvxopt status={}'.format(status_)) self.status = OPTIMAL self.objective = primal_objective_ _x = self.result['x'] self._x = np.array(_x).flatten() _z = self.result['z'] self._z = np.array(_z).flatten()[:-1] # remove the dummy constraint
def intervention(self, t): # for item in range(self.n): if t == self.tf[item]: #发生故障 print('故障发生在t = %s s' % self.tf[item]) #启用故障 self.u[item] = 1 system.DAE.factorize = True #存储故障前 self._ang = matrix(system.DAE.y[system.Bus.a]) self._vol = matrix( system.DAE.y[system.Bus.n:len(system.DAE.y)]) if t == self.tc[item]: #故障清除 print('在t = %s s清除故障' % self.tc[item]) # 禁用故障 self.u[item] = 0 system.DAE.factorize = True #恢复电压 if system.Settings.resetangles: system.DAE.y[system.Bus.a] = matrix(self._ang) system.DAE.y[system.Bus.n:len(system.DAE.y)] = matrix( self._vol)
def Gycall(self): system.DAE.y = matrix(system.DAE.y) U = exp(system.DAE.y[system.Bus.a] * 1j) V = mul(system.DAE.y[system.Bus.v] + 0j, U) I = self.Y * V nb = len(system.Bus.a) diagU = spmatrix(U, system.Bus.a, system.Bus.a, (nb, nb), 'z') diagV = spmatrix(V, system.Bus.a, system.Bus.a, (nb, nb), 'z') diagI = spmatrix(I, system.Bus.a, system.Bus.a, (nb, nb), 'z') dS = self.Y * diagU dS = diagV * dS.H.T dS += diagI.H.T * diagU dR = diagI dR = dR - self.Y * diagV dR = diagV.H.T * dR # system.DAE.Gy = matrix(0.0, (system.DAE.ny, system.DAE.ny)) # # system.DAE._list2matrix() # system.DAE.Gy = spmatrix(dR.imag().V, dR.imag().I, dR.imag().J, (system.DAE.ny, system.DAE.ny)) \ # + spmatrix(dR.real().V, dR.real().I, dR.real().J+system.Bus.n, (system.DAE.ny, system.DAE.ny)) \ # + spmatrix(dS.real().V, dS.real().I+system.Bus.n, dS.real().J, (system.DAE.ny, system.DAE.ny)) \ # + spmatrix(dS.imag().V, dS.imag().I+system.Bus.n, dS.imag().J+system.Bus.n, (system.DAE.ny, system.DAE.ny)) Gy = sparse([[dR.imag(), dR.real()], [dS.real(), dS.imag()]]) # system.DAE.Gy = zeros([system.DAE.ny,system.DAE.ny]) system.DAE.Gy = spmatrix(Gy.V, Gy.I, Gy.J, (system.DAE.ny, system.DAE.ny)) system.DAE.Gy = matrix(system.DAE.Gy)
def gcall(self): if self.n == 0: return system.DAE.y = matrix(system.DAE.y) V = system.DAE.y[self.v] V2 = mul(V, V) p = mul(matrix(self.g), V2) q = mul(matrix(self.b), V2) # #V = matrix(0, (system.Shunt.n, 1)) # V = [1.0] * system.Shunt.n # print(V) # for i in range(system.Shunt.n): # V[i] = system.DAE.y[self.v[i]] # print(V) # V = np.array(V) # V2 = V * V # print(V2) # J = [1] * system.Shunt.n # print(self.a) # print(J) # p = [0] * system.Shunt.n # q = [0] * system.Shunt.n # for i in range(system.Shunt.n): # p[i] = self.g[i] * V2[i] # q[i] = self.b[i] * V2[i] for key, value in zip(self.a, p): system.DAE.g[key] += value for key, value in zip(self.v, q): system.DAE.g[key] -= value
def yinit(self, dae): zeros = [0.0] * (2 * self.n) dae.y = zeros[:] dae.g = zeros[:] for i in range(self.n): if self.V_0[i] < 0.5: print( 'Warning: Bus %i initial guess voltage magnitudes are too low.' % i) if self.V_0[i] > 1.5: print( 'Warning: Bus %i initial guess voltage magnitudes are too high.' % i) system.DAE.y = matrix(system.DAE.y) system.DAE.y[self.v] = self.V_0 aref = min(abs(matrix(self.theta0))) for i in range(self.n): if self.theta0[i] - aref < -1.5708: print( 'Warning: Bus %i initial guess voltage phases are too low.' % i) if self.theta0[i] - aref > 1.5708: print( 'Warning: Bus %i initial guess voltage phases are too high.' % i) system.DAE.y[self.a] = self.theta0
def fcall(self): if self.n == 0: return tg1 = system.DAE.x[self.tg1] tg2 = system.DAE.x[self.tg2] tg3 = system.DAE.x[self.tg3] wref = system.DAE.y[self.wref] gain = div(matrix(1.0, (self.n, 1)), self.R) a_s = div(matrix(1.0, (self.n, 1)), self.Ts) ac = div(matrix(1.0, (self.n, 1)), self.Tc) a5 = div(matrix(1.0, (self.n, 1)), self.T5) K1 = mul(self.T3, ac) K2 = 1 - K1 K3 = mul(self.T4, a5) K4 = 1 - K3 system.Syn6.omega = matrix(system.Syn6.omega) omega = system.Syn6.omega[self.a] tin = self.Porder + mul(gain, wref - system.DAE.x[omega]) for i in range(self.n): tin[i] = max(tin[i], self.Pmin[i]) tin[i] = min(tin[i], self.Pmax[i]) system.DAE.f[self.tg1] = mul(self.u, a_s, -tg1+tin) system.DAE.f[self.tg2] = mul(self.u, ac, -tg2 + mul(K2, tg1)) system.DAE.f[self.tg3] = mul(self.u, a5, -tg2 + mul(K4, tg2+mul(K1, tg1)))
def _gen_mtxnormsdp(self,p,q,r,d,seed): """ Random data generator for matrix norm minimization SDP. """ setseed(seed) n = p + q; I = matrix([ i for j in range(q) for i in range(q,n)]) J = matrix([ j for j in range(q) for i in range(q,n)]) Il = list(misc.sub2ind((n,n),I,J)) if type(d) is float: nz = min(max(1, int(round(d*p*q))), p*q) A = sparse([[spmatrix(normal(p*q,1),Il,[0 for i in range(p*q)],(n**2,1))], [spmatrix(normal(nz*r,1), [i for j in range(r) for i in random.sample(Il,nz)], [j for j in range(r) for i in range(nz)],(n**2,r))]]) elif type(d) is list: if len(d) == r: nz = [min(max(1, int(round(v*p*q))), p*q) for v in d] nnz = sum(nz) A = sparse([[spmatrix(normal(p*q,1),Il,[0 for i in range(p*q)],(n**2,1))], [spmatrix(normal(nnz,1), [i for j in range(r) for i in random.sample(Il,nz[j])], [j for j in range(r) for i in range(nz[j])],(n**2,r))]]) else: raise TypeError self._A = sparse([[A],[spmatrix(-1.,list(range(0,n**2,n+1)),[0 for i in range(n)],(n**2,1))]]) self._b = matrix(0.,(r+1,1)) self._b[-1] = -1.
def sum_weights_equal_1_constraint( assets_number: int) -> Tuple[matrix, matrix]: """ Creates a constraint which assures that all weights sum up to 1. """ A = matrix(1.0, (1, assets_number)) b = matrix(1.0) return A, b
def find_alphas(P, q, G, h): # Utilisation de cvxopt: cf enonce du TP r = qp(matrix(P), matrix(q), matrix(G), matrix(h)) alphas = np.array(list(r['x'])) # remplacer les valeurs trop petites par 0, garder le reste alphas = np.where(np.fabs(alphas) < 10e-5, 0, alphas) return alphas
def test_negative(self): t = self.solver.calculate( self.tols_vector, self.flows_vector.transpose(), self.incidence_matrix, np.zeros(self.solver.data['graph']['nodeCount']), matrix(self.A_for_negative_test_2.transpose()), matrix(self.b_for_negative_test_2.transpose())) self.assertEqual(t, None)
def build_qGh(n): print('Building q, G, h...') q = matrix(-1., (n, 1)) h = matrix(0., (n, 1)) G = matrix(0., (n, n)) G[::(n + 1)] = -1 return q, h, G
def l1regls(A, b, gamma): """ minimize 0.5 * ||A*x-b||_2^2 + gamma*sum_k |x_k| with complex data. """ A=matrix(A) b=matrix(b) m, n = A.size # Solve as # # minimize 0.5 * || AA*u - bb ||_2^2 + gamma* sum(t) # subject || (u[k], u[k+n]) ||_2 <= t[k], k = 0, ..., n-1. # # with real data and u = ( Re(x), Im(x) ). AA = matrix([ [A.real(), A.imag()], [-A.imag(), A.real()] ]) bb = matrix([ b.real(), b.imag() ]) # P = [AA'*AA, 0; 0, 0] P = matrix(0.0, (3*n, 3*n)) P[0:2*n,0:2*n]=AA.T*AA # q = [-AA'*bb; gamma*ones] q = matrix([-AA.T * bb, matrix(gamma, (n,1))]) # n second order cone constraints || (u[k], u[k+n]) ||_2 <= t[k] I = matrix(0.0, (n,n)) I[::n+1] = -1.0 G = matrix(0.0, (3*n, 3*n)) G[1::3, :n] = I G[2::3, n:2*n] = I G[::3, -n:] = I def Gfun(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): gx=matrix(0.0,x.size) if trans=='N': gx[1::3,:]=-x[ : n,:] gx[2::3,:]=-x[ n:2*n,:] gx[ ::3,:]=-x[-n: ,:] elif trans=='T': gx[ : n,:]=-x[1::3,:] gx[ n:2*n,:]=-x[2::3,:] gx[-n: ,:]=-x[ ::3,:] y[:,:]=alpha*gx+beta*y h = matrix(0.0, (3*n, 1)) dims = {'l': 0, 'q': n*[3], 's': []} factor=mykktchol(P) sol = solvers.coneqp(P, q, Gfun, h, dims,kktsolver=factor) return sol['x'][:n] + 1j*sol['x'][n:2*n]
def classifier(Y, soft = False): M = Y.size[0] x = matrix(b, (M,1)) #print('b ( = w_0)') #print(b) #print('about to print long vector?') blas.gemv(Y, w, x, beta = 1.0) if soft: return x else: return matrix([ 2*(xk > 0.0) - 1 for xk in x ])
def classifier(Y, soft=False): M = Y.size[0] # K = Y*X' / sigma K = matrix(0.0, (M, Nr)) blas.gemm(Y, Xr, K, transB='T', alpha=1.0 / sigma) x = K**degree * zr + b if soft: return x else: return matrix([2 * (xk > 0.0) - 1 for xk in x])
def maximize_fapx_cvxopt( node, problem, scoop=False): ''' Finds the value of y solving maximize sum(fapx(x)) subject to: constr l <= x <= u fapx is calculated by approximating the functions given in fs as the concave envelope of the function that is tight, for each coordinate i, at the points in tight[i] fs should be a list of tuples containing the function and its derivative corresponding to each coordinate of the vector x. Returns a dict containing the optimal variable y as a list, the optimal value of the approximate objective, and the value of sum(f(x)) at x. scoop = True optionally dumps all problem parameters into a file which can be parsed and solved using the scoop second order cone modeling language ''' n = len(node.l); l = matrix(node.l); u = matrix(node.u) x = problem.variable constr = problem.constr # add box constraints box = [x[i]<=u[i] for i in xrange(n)] + [x[i]>=l[i] for i in xrange(n)] # find approximation to concave envelope of each function (fapx,slopes,offsets,fapxs) = utilities.get_fapx(node.tight,problem.fs,l,u,y=x) if problem.check_z: utilities.check_z(problem,node,fapx,x) if scoop: utilities.scoop(p,node,slopes,offsets) obj = sum( fapx ) o = op(obj,constr + box) try: o.solve(solver = 'glpk') except: o.solve() if not o.status == 'optimal': if o.status == 'unknown': raise ImportError('Unable to solve subproblem. Please try again after installing cvxopt with glpk binding.') else: # This node is dead, since the problem is infeasible return False else: # find the difference between the fapx and f for each coordinate i fi = numpy.array([problem.fs[i][0](x.value[i]) for i in range(n)]) fapxi = numpy.array([list(-fun.value())[0] for fun in fapx]) #if verbose: print 'fi',fi,'fapxi',fapxi maxdiff_index = numpy.argmax( fapxi - fi ) results = {'x': list(x.value), 'fapx': -list(obj.value())[0], 'f': float(sum(fi)), 'maxdiff_index': maxdiff_index} return results
def robustLS_toep(q, r, delta=None, seed=0): """ Random data generator for matrix norm minimization SDP. Al,b = robustLS_toep(q,r,delta=0.1,seed=0]) PURPOSE Generates random data for a robust least squares problem with Toeplitz structure: minimize e_wc(x)^2 where e_wc(x)=sup_{norm(u)<=1} norm((Ab+A1*u1+...+Ar*ur)*x - b), Ab,A1,...,Ar \in \reals^{p \times q} The parameter r determines the number of nonzero diagonals in Ab (1 <= r <= p). ARGUMENTS q integer r integer delta float RETURNS Al list of CVXOPT matrices, [Ab,A1,...,Ar] b CVXOPT matrix """ setseed(seed) p = q + r - 1 Alist = [ sparse( misc.toeplitz( matrix([normal(r, 1), matrix(0., (p - r, 1))], (p, 1)), matrix(0., (q, 1)))) ] x = normal(q, 1) b = normal(p, 1, std=0.1) b += Alist[0] * x if delta is None: delta = 1. / r for i in xrange(r): Alist.append( spmatrix(delta, xrange(i, min(p, q + i)), xrange(min(q, p - i)), (p, q))) return robustLS_SDP(Alist, b)
def train(training_data: List[Tuple[float, float, float]], kernel: Callable = linear_kernel, slack: bool = False, C: float = None) -> Callable: if slack: assert C X = [(e[0], e[1]) for e in training_data] T = [e[2] for e in training_data] N = len(training_data) # build P P = numpy.empty(shape=(N, N)) for i in range(N): for j in range(N): P[i][j] = T[i] * T[j] * kernel(X[i], X[j]) # build q q = numpy.ones(N) * -1 # build h h = None if slack: h = numpy.empty(2 * N) for i in range(N): h[i] = 0 for i in range(N, 2 * N): h[i] = C else: h = numpy.zeros(N) # build G G = numpy.zeros(shape=(2 * N, N)) if slack else numpy.zeros(shape=(N, N)) for i, j in zip(range(N), range(N)): G[i][j] = -1 if slack: for i, j in zip(range(N, 2 * N), range(N)): G[i][j] = 1 r = qp(matrix(P), matrix(q), matrix(G), matrix(h)) alpha = list(r['x']) # get all non-zero alphas and corresponding points and classes alpha_nz = [] for i in range(len(alpha)): if alpha[i] >= FLOAT_THRESHOLD: alpha_nz.append((alpha[i], X[i], T[i])) def indicator(nX): sum = 0.0 for (a, x, t) in alpha_nz: sum += a * t * kernel(nX, x) return sum return indicator
def numerical_gradient(x_k, func, epsilon, *args): n_params, one = x_k.size assert one==1 ei = cvx.matrix(0.0, x_k.size) grad = cvx.matrix(0.0, x_k.size) for i in range(n_params): ei[i] = epsilon grad[i] = ( func(x_k+ei, *args) - func(x_k-ei, *args) ) / (2*epsilon) ei[i] = 0.0 return grad.T
def generateAlpha(P,q,h,G): threshold = 0.00001 r = qp(matrix(P), matrix(q), matrix(G, (2*len(data), len(data)), 'd'), matrix(h)) if(r['status'] != 'optimal'): print "I failed =(" exit(-1) alpha = list(r['x']) for a in xrange(len(alpha)): if abs(alpha[a]) < threshold: alpha[a] = 0.0 return alpha
def update_h(self): def updatesingleH(i): # optimize alpha using qp solver from cvxopt FA = base.matrix(np.float64(np.dot(-self.W.T, self.data[:,i]))) al = solvers.qp(HA, FA, INQa, INQb) self.H[:,i] = np.array(al['x']).reshape((1,-1)) # float64 required for cvxopt HA = base.matrix(np.float64(np.dot(self.W.T, self.W))) INQa = base.matrix(-np.eye(self._num_bases)) INQb = base.matrix(0.0, (self._num_bases,1)) map(updatesingleH, xrange(self._num_samples))
def update_w(self): def updatesingleW(i): # optimize alpha using qp solver from cvxopt FA = base.matrix(np.float64(np.dot(-self.H, self.data[i,:].T))) al = solvers.qp(HA, FA, INQa, INQb) self.W[i,:] = np.array(al['x']).reshape((1,-1)) # float64 required for cvxopt HA = base.matrix(np.float64(np.dot(self.H, self.H.T))) INQa = base.matrix(-np.eye(self._num_bases)) INQb = base.matrix(0.0, (self._num_bases,1)) map(updatesingleW, xrange(self._data_dimension))
def _gen_randsdp(self,V,m,d,seed): """ Random data generator """ setseed(seed) n = self._n V = chompack.tril(V) N = len(V) I = V.I; J = V.J Il = misc.sub2ind((n,n),I,J) Id = matrix([i for i in range(len(Il)) if I[i]==J[i]]) # generate random y with norm 1 y0 = normal(m,1) y0 /= blas.nrm2(y0) # generate random S0, X0 S0 = mk_rand(V,cone='posdef',seed=seed) X0 = mk_rand(V,cone='completable',seed=seed) # generate random A1,...,Am if type(d) is float: nz = min(max(1, int(round(d*N))), N) A = sparse([[spmatrix(normal(N,1),Il,[0 for i in range(N)],(n**2,1))], [spmatrix(normal(nz*m,1), [i for j in range(m) for i in random.sample(Il,nz)], [j for j in range(m) for i in range(nz)],(n**2,m))]]) elif type(d) is list: if len(d) == m: nz = [min(max(1, int(round(v*N))), N) for v in d] nnz = sum(nz) A = sparse([[spmatrix(normal(N,1),Il,[0 for i in range(N)],(n**2,1))], [spmatrix(normal(nnz,1), [i for j in range(m) for i in random.sample(Il,nz[j])], [j for j in range(m) for i in range(nz[j])],(n**2,m))]]) else: raise TypeError # compute A0 u = +S0.V for k in range(m): base.gemv(A[:,k+1][Il],matrix(y0[k]),u,beta=1.0,trans='N') A[Il,0] = u self._A = A # compute b X0[Il[Id]] *= 0.5 self._b = matrix(0.,(m,1)) u = matrix(0.) for k in range(m): base.gemv(A[:,k+1][Il],X0.V,u,trans='T',alpha=2.0) self._b[k] = u
def svmMain(indata, kernel, figure, par1, par2, C): print "Defining the variables needed for vecktor machine" N = len(indata) P = matrix(buildPMatrix(indata, kernel, par1, par2)) #G = spmatrix(-1.0, range(2*N), range(N)) G = np.zeros((2*N,N)) for i in range(0,N): G[i,i] = -1.0 for i in range(N+1,2*N): G[i,i-N] = 1.0 #print G G = matrix(G) q = matrix(np.linspace(-1,-1,N)) h = matrix(np.zeros(2*N)) for i in range(N, (2*N)-1): h[i] = C #print h print "Calling qp, solving the linear equation" r = qp(P, q, G, h) alpha = list(r['x']) print "Finding the non zero alpha that minimizes the linear equation" indicationMapping = [] epsylon = 0.00001 for i in range(N): if alpha[i] > epsylon: indicationMapping.append([alpha[i],data[i]]) print "Found ", len(indicationMapping), " non zero alphas" print "Printing data!" figure.hold(True) figure.plot([p[0] for p in classA], [p[1] for p in classA], 'bo') figure.plot([p[0] for p in classB], [p[1] for p in classB], 'ro') print "Setting up massive grid" xrange = np.arange(-4, 4, 0.05) yrange = np.arange(-4, 4, 0.05) grid = matrix([[indicator(x, y, indicationMapping, kernel, par1, par2) for y in yrange] for x in xrange]) figure.contour(xrange, yrange, grid, (-1.0, 0.0, 1.0), colors=('red', 'black', 'blue'), linewidths=(1, 3, 1))
def solve_optimization(self, train_x, labels): Q = self.build_Q(train_x, labels) p = [-1.0] * train_x.shape[0] if self.with_slack: h = [0.0] * train_x.shape[0] + [self.C] * train_x.shape[0] G = np.concatenate((np.identity(train_x.shape[0]) * -1, np.identity(train_x.shape[0]))) else: h = [0.0] * train_x.shape[0] G = np.identity(train_x.shape[0]) * -1 optimized = qp(matrix(Q), matrix(p), matrix(G), matrix(h)) if optimized['status'] == 'optimal': alphas = list(optimized['x']) self.support_vector = [(alpha, train_x[i,:],labels[i]) for i,alpha in enumerate(alphas) if alpha>self.epsilon] return True else: print "No valid separating hyperplane found" print "Find a best hyperplane for the mixture data..." h = [0.0] * train_x.shape[0] + [self.C] * train_x.shape[0] G = np.concatenate((np.identity(train_x.shape[0]) * -1, np.identity(train_x.shape[0]))) optimized = qp(matrix(Q), matrix(p), matrix(G), matrix(h)) alphas = list(optimized['x']) self.support_vector = [(alpha, train_x[i,:],labels[i]) for i,alpha in enumerate(alphas) if alpha>self.epsilon] return False
def robustLS_toep(q,r,delta=None,seed=0): """ Random data generator for matrix norm minimization SDP. Al,b = robustLS_toep(q,r,delta=0.1,seed=0]) PURPOSE Generates random data for a robust least squares problem with Toeplitz structure: minimize e_wc(x)^2 where e_wc(x)=sup_{norm(u)<=1} norm((Ab+A1*u1+...+Ar*ur)*x - b), Ab,A1,...,Ar \in \reals^{p \times q} The parameter r determines the number of nonzero diagonals in Ab (1 <= r <= p). ARGUMENTS q integer r integer delta float RETURNS Al list of CVXOPT matrices, [Ab,A1,...,Ar] b CVXOPT matrix """ setseed(seed) p = q+r-1 Alist = [sparse(misc.toeplitz(matrix([normal(r,1),matrix(0.,(p-r,1))],(p,1)),matrix(0.,(q,1))))] x = normal(q,1) b = normal(p,1,std=0.1) b += Alist[0]*x if delta is None: delta = 1./r for i in range(r): Alist.append(spmatrix(delta,range(i,min(p,q+i)),range(min(q,p-i)),(p,q))) return robustLS_SDP(Alist, b)
def CVXOPT_SOCP_Solver(p, solverName): if solverName == 'native_CVXOPT_SOCP_Solver': solverName = None cvxopt_solvers.options['maxiters'] = p.maxIter cvxopt_solvers.options['feastol'] = p.contol cvxopt_solvers.options['abstol'] = p.ftol if p.iprint <= 0: cvxopt_solvers.options['show_progress'] = False cvxopt_solvers.options['LPX_K_MSGLEV'] = 0 cvxopt_solvers.options['MSK_IPAR_LOG'] = 0 xBounds2Matrix(p) #FIXME: if problem is search for MAXIMUM, not MINIMUM!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! f = copy(p.f).reshape(-1,1) # CVXOPT has some problems with x0 so currently I decided to avoid using the one Gq, hq = [], [] C, d, q, s = p.C, p.d, p.q, p.s for i in range(len(q)): Gq.append(Matrix(Vstack((-atleast_1d(q[i]),-atleast_1d(C[i]) if not isspmatrix(C[i]) else C[i])))) hq.append(matrix(hstack((atleast_1d(s[i]), atleast_1d(d[i]))), tc='d')) sol = cvxopt_solvers.socp(Matrix(p.f), Gl=Matrix(p.A), hl = Matrix(p.b), Gq=Gq, hq=hq, A=Matrix(p.Aeq), b=Matrix(p.beq), solver=solverName) p.msg = sol['status'] if p.msg == 'optimal' : p.istop = SOLVED_WITH_UNIMPLEMENTED_OR_UNKNOWN_REASON else: p.istop = -100 if sol['x'] is not None: p.xf = asarray(sol['x']).flatten() p.ff = sum(p.dotmult(p.f, p.xf)) else: p.ff = nan p.xf = nan*ones(p.n)
def build_p_matrix(points, classes, K): N = len(points) P = matrix(0.0, (N, N)) for i in range(0, N): for j in range(0, N): P[i, j] = classes[i] * classes[j] * K(points[i], points[j]) return P
def build_inv_weight(w, exact_mask=None): # as it is this function now if, for a certain k, w[k,k] is zero and # exact_mask[k] is true at the same time, the first take precedence, # that is the corresponing parameter will not be matched at all. I = [] J = [] E = [] kk = 0 for k in range(0,w.size[0]): if not w[k,k] == 0: I.append(kk) J.append(k) E.append(1.0) kk += 1 if exact_mask is not None and w[k,k] == 0: del exact_mask[kk] I.append(kk-1) J.append(k) E.append(0.0) M = cb.spmatrix(E, I, J) w_r = M*w*M.T i_w_r = cb.matrix(linalg.inv(w_r)) if exact_mask is None: return i_w_r, M for k in range(0,len(exact_mask)): if exact_mask[k]: i_w_r[k,:] = 0.0 i_w_r[:,k] = 0.0 return i_w_r, M
def DictToList(d): i = 0 r = [] while i in d.keys(): r.append(matrix(d[i], tc = 'd')) i += 1 return r
def contour(list): xrange = numpy.arange(-5, 5, 0.05) yrange = numpy.arange(-5, 5, 0.05) grid = matrix([[indicator(x, y, list) for y in yrange] for x in xrange]) pylab.contour(xrange, yrange, grid, (-1.0, 0.0, 1.0), colors=('red', 'black', 'blue'), linewidths=(1, 3, 1)) pylab.show()
def uniform(nrows, ncols=1, a=0, b=1): ''' Randomly generates a matrix with uniformly distributed entries. uniform(nrows, ncols=1, a=0, b=1) PURPOSE Returns a matrix with typecode 'd' and size nrows by ncols, with its entries randomly generated from a uniform distribution on the interval (a,b). ARGUMENTS nrows number of rows ncols number of columns a lower bound b upper bound ''' try: from cvxopt import gsl except: from cvxopt.base import matrix from random import uniform return matrix([uniform(a, b) for k in range(nrows*ncols)], (nrows,ncols), 'd' ) return gsl.uniform(nrows, ncols, a, b)
def normal(nrows, ncols=1, mean=0.0, std=1.0): ''' Randomly generates a matrix with normally distributed entries. normal(nrows, ncols=1, mean=0, std=1) PURPOSE Returns a matrix with typecode 'd' and size nrows by ncols, with its entries randomly generated from a normal distribution with mean m and standard deviation std. ARGUMENTS nrows number of rows ncols number of columns mean approximate mean of the distribution std standard deviation of the distribution ''' try: from cvxopt import gsl except: from cvxopt.base import matrix from random import gauss return matrix([gauss(mean, std) for k in range(nrows*ncols)], (nrows,ncols), 'd' ) return gsl.normal(nrows, ncols, mean, std)
def main(): print("Running main method.") print("") # Generate the datapoints and plot them. classA, classB = gen_datapoints_helper() kernels = [LINEAR, POLYNOMIAL, RADIAL_BASIS, SIGMOID] for k in kernels: pylab.figure() pylab.title(kernel_name(k)) 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') # Add the sets together and shuffle them around. datapoints = gen_datapoints_from_classes(classA, classB) t= train(datapoints, k) # Plot the decision boundaries. xr=numpy.arange(-4, 4, 0.05) yr=numpy.arange(-4, 4, 0.05) grid=matrix([[indicator(t, x, y, k) for y in yr] for x in xr]) pylab.contour(xr, yr, grid, (-1.0, 0.0, 1.0), colors=('red', 'black', 'blue'), linewidths=(1, 3, 1)) # Now that we are done we show the ploted datapoints and the decision # boundary. pylab.show()
def buildPMatrix(datapoints, kernel, par1, par2): tempMatrix = matrix(0.1,(len(datapoints),len(datapoints))) for i in range(len(datapoints)): for j in range(len(datapoints)): #print "solving P, point (x, y) (",i,", ",j,")" tempMatrix[i,j] = datapoints[i][2]*datapoints[j][2]*kernel( [datapoints[i][0], datapoints[i][1]], [datapoints[j][0], datapoints[j][1]], par1, par2) return tempMatrix
def plot_decision_boundary(machine): x_range = numpy.arange(-4, 4, 0.05) y_range = numpy.arange(-4, 4, 0.05) grid = matrix([[machine.indicator((x, y)) for y in y_range] for x in x_range]) pylab.contour(x_range, y_range, grid, (-1.0, 0.0, 1.0), colors=('red', 'black', 'blue'), linewidths=(1, 3, 1))