def __init__(self, inpDim, hidDim): self.inpDim = inpDim #number of input neurons (and output neurons) self.hidDim = hidDim #number of hidden neurons self.inp = zeros((self.inpDim, 1)) #vector holding current input self.out = zeros((self.hidDim, 1)) #output neurons self.g = zeros((self.hidDim, 1)) #neural activity before non-linearity self.h = zeros((self.hidDim, 1)) #hidden neuron activation self.a = ones((self.hidDim, 1)) #slopes of activation functions self.b = -3 * ones((self.hidDim, 1)) #biases of activation functions scale = 0.025 self.W = scale * ( 2 * rand((self.inpDim, self.hidDim)) - 0.5 * ones( (self.inpDim, self.hidDim)) ) + scale #shared network weights, i.e. used to compute hidden layer activations and estimated outputs print self.W.shape self.lrateRO = 0.01 #learning rate for synaptic plasticity of read-out layer (RO) self.regRO = 0.0002 #numerical regularization constant self.decayP = 0 #decay factor for positive weights [0..1] self.decayN = 1 #decay factor for negative weights [0..1] self.lrateIP = 0.001 #learning rate for intrinsic plasticity (IP) self.meanIP = 0.2
def neglnlikelihood(self): ye = copy.deepcopy(self.ye) # calculate mu_d dd = ye - self.rho * self.yc_xe # a = np.linalg.solve(self.UPsid_Xe.T,dd) # b = np.linalg.solve(self.UPsid_Xe,a) c = ones([self.ne,1]).T.dot(np.mat(self.Psid_Xe).I.dot(dd)) # d = np.linalg.solve(self.UPsid_Xe.T, ones([self.ne,1])) # e = np.linalg.solve(self.UPsid_Xe,d) f = ones([self.ne,1]).T.dot(np.mat(self.Psid_Xe).I.dot(ones([self.ne,1]))) self.mud = c/f # let's solve sigmaSqrd # notice that here yc is alist, it should be transfered to n*1 array d = ye - self.rho * self.yc_xe - ones([self.ne, 1]).dot(self.mud) # a = np.linalg.solve(self.UPsid_Xe.T, d) # b = np.linalg.solve(self.UPsid_Xe, a) self.sigmaSqrd = d.T.dot(np.mat(self.Psid_Xe).I.dot(d)) / self.ne # self.LnDetPsid = 2. * np.sum(np.log(np.abs(np.diag(self.UPsid_Xe)))) self.LnDetPsid = np.log(np.abs(np.linalg.det(self.Psid_Xe))) self.NegLnLike = -1.*(-(self.ne/2.)*np.log(self.sigmaSqrd[0,0]) - 0.5*self.LnDetPsid)
def inf(self, x, meanonly=False): x = np.asmatrix(x) if x.shape[1] != self.d: if x.shape[0] == self.d: x = x.T else: raise Exception('Invalid test-set dimension -- ' 'expected d = ' + str(self.d) + '.') n = x.shape[0] # Handle empty test set if n == 0: return (np.zeros((0, 1)), np.zeros((0, 1))) ms = self.kernel.mean*np.ones((n, 1)) Kbb = self.kernel(x, diag=True) # Handle empty training set if len(self) == 0: return (ms, np.asmatrix(Kbb)) Kba = self.kernel(x, self.x) m = self.kernel.mean*np.ones((len(self), 1)) fm = ms + Kba*scipy.linalg.cho_solve((self.L, True), self.y - m, overwrite_b=True) if meanonly: return fm else: W = scipy.linalg.cho_solve((self.L, True), Kba.T) fv = np.asmatrix(Kbb - np.sum(np.multiply(Kba.T, W), axis=0).T) # W = np.asmatrix(scipy.linalg.solve(self.L, Kba.T, lower=True)) # fv = np.asmatrix(Kbb - np.sum(np.power(W, 2), axis=0).T) return (fm, fv)
def followup(A, b): """Thomas solver of A*x = b, where A is a tri-diagonal matrix Returns ------- x : solution of A*x = b """ n = A.shape[0] d = matlib.ones([n, 1]) a = matlib.ones([n - 1, 1]) c = matlib.ones([n - 1, 1]) x = matlib.ones(n) for i in range(n - 1): a[i, 0] = A[i + 1, i] c[i, 0] = A[i, i + 1] d[i, 0] = A[i, i] d[n - 1, 0] = A[n - 1, n - 1] for i in range(1, n): ad = a[i - 1, 0] / d[i - 1, 0] d[i, 0] = d[i, 0] - ad * c[i - 1, 0] b[i, 0] = b[i, 0] - ad * b[i - 1, 0] x[0, n - 1] = b[n - 1, 0] / d[n - 1, 0] for i in range(n - 2, -1, -1): x[0, i] = (b[i, 0] - c[i, 0] * x[0, i + 1]) / d[i, 0] return x
def MakeWind(speedmean, speedstd, dirmean, dirstd, n): """ Uses auto-regressive process to compute a set of wind x/y velocities. Returns a 2-item list where each item is a list of all the x/y velocities respectively. """ N = 10 phispeed = matlib.ones((1, N)) / N * 0.99 phidir = matlib.ones((1, N)) / N * 0.99 s0 = speedmean d0 = dirmean speeds = [s0] dirs = [d0] xs = [] ys = [] espeed = lambda: random.normal(speedmean, speedstd) edir = lambda: random.normal(dirmean, dirstd) for ii in range(1, n+1): Xspeed = matlib.zeros(phispeed.shape).T Xdir = matlib.zeros(phidir.shape).T for jj in range(N): idx = max(ii + jj - N, 0) Xspeed[jj, 0] = speeds[idx] - speedmean Xdir[jj, 0] = dirs[idx] - dirmean speeds.append(float(phispeed * Xspeed + espeed())) dirs.append(float(phidir * Xdir + edir())) xs.append(speeds[-1] * np.cos(dirs[-1])) ys.append(speeds[-1] * np.sin(dirs[-1])) return [xs, ys]
def echo_encode(original_audio: Audio, mark: bytes, alpha: float = 0.7, m: tuple = (150, 200)) -> Audio: """ 用回声隐藏进行隐写。 优点:透明性强,写入的数据并非噪声,鲁棒性好,抗压缩性好。 缺点:容量小,这里默认是8192个取样点写入一个比特。 :param original_audio: 原音频,为一个Audio对象 :param mark: 水印,必须为一个bytes对象 :param alpha: 衰退率,理论上这个值越大水印鲁棒性越好,但生成的音频回音会更强 :param m: 回音的延迟,分别为比特0和比特1的延迟 :return: 隐写后的音频,为一个Audio对象 """ if not isinstance(mark, bytes): raise MarkFormatError("Mark must be a bytes object.") if alpha > 1 or alpha < 0: raise MarkFormatError("Alpha must be in [0,1].") bits = np.mat(get_all_bits(mark)) bits_len = bits.shape[1] original_samples_reg = np.matrix(original_audio.get_reshaped_samples()) samples_len = original_samples_reg.shape[1] channels = original_audio.channels if 8192 * bits_len > samples_len: raise MarkTooLargeError("Mark too large for echo encoding.") fragment_len = samples_len // bits_len encoded_len = bits_len * fragment_len kernel0 = np.concatenate((mt.zeros( (channels, m[0])), alpha * original_samples_reg), 1) kernel1 = np.concatenate((mt.zeros( (channels, m[1])), alpha * original_samples_reg), 1) # 这里是两个回声核,0代表隐藏信息的0,1代表隐藏信息的1 direct_sig = np.reshape( np.matrix(mt.ones((fragment_len, 1))) * bits, (encoded_len, 1), 'F') smooth_length = int( np.floor(fragment_len / 4) - np.floor(fragment_len / 4) % 4) tp = np.matrix( fftconvolve(np.array(direct_sig)[:, 0], np.hanning(smooth_length))) # 这里用的是汉宁窗口,其他窗口的效果类似 window = tp[0, smooth_length // 2:tp.shape[1] - smooth_length // 2 + 1] / np.max(np.abs(tp)) # window 用于平滑 mixer = mt.ones((channels, 1)) * window # 这里的 channels 很关键,需要写入所有的音轨 encoded_samples_reg = original_samples_reg[:, :encoded_len] + \ np.multiply(kernel1[:, :encoded_len], mixer) + \ np.multiply(kernel0[:, :encoded_len], abs(mixer - 1)) # 这里是回音合成 new_samples_reg = np.concatenate( (encoded_samples_reg, original_samples_reg[:, encoded_len:]), 1) new_audio = original_audio.spawn(new_samples_reg) new_audio.key = { 'type': 'SINGLE_ECHO', 'key': { 'm': m, 'fragment_len': fragment_len, 'bits_len': bits_len } } return new_audio
def getOrthColumns(m): ''' Constructs the orthogonally complementing columns of the input. Input of the form pxr is assumed to have r<=p, and have either full column rank r or rank 0 (scalar or matrix) Output is of the form px(p-r), except: a) if M square and full rank p, returns scalar 0 b) if rank(M)=0 (zero matrix), returns I_p (Note you cannot pass scalar zero, because dimension info would be missing.) Return type is as input type. ''' if type(m) == type(asarray(m)): m = mat(m) output = 'array' else: output = 'matrix' p, r = m.shape # first catch the stupid input case if p < r: raise ValueError, 'need at least as many rows as columns' # we use lstsq(M, ones) just to exploit its rank-finding algorithm, rk = lstsq(m, ones(p).T)[2] # first the square and full rank case: if rk == p: result = zeros((p,0)) # note the shape! hopefully octave-like # then the zero-matrix case (within machine precision): elif rk == 0: result = eye(p) # now the rank-deficient case: elif rk < r: raise ValueError, 'sorry, matrix does not have full column rank' # (what's left should be ok) else: # we have to watch out for zero rows in M, # if they are in the first p-r positions! # so the (probably inefficient) algorithm: # 1. check the rank of each row # 2. if zero, then also put a zero row in c # 3. if not, put the next unit vector in c-row idr = eye(r) idpr = eye(p-r) c = empty([0,r]) # starting point co = empty([0, p-r]) # will hold orth-compl. idrcount = 0 for row in range(p): # (must be ones() instead of 1 because of 2d-requirement if lstsq( m[row,:], ones(1) )[2] == 0 or idrcount >= r: c = r_[ c, zeros(r) ] co = r_[ co, idpr[row-idrcount, :] ] else: # row is non-zero, and we haven't used all unit vecs c = r_[ c, idr[idrcount, :] ] co = r_[ co, zeros(p-r) ] idrcount += 1 # earlier non-general (=bug) line: c = mat(r_[eye(r), zeros((p-r, r))]) # and: co = mat( r_[zeros((r, p-r)), eye(p-r)] ) # old: # result = ( eye(p) - c * (M.T * c).I * M.T ) * co result = co - c * solve(m.T * c, m.T * co) if output == 'array': return result.A else: return result
def AttachContact(name): i = contact_frames.index(name) contacts[i] = tsid.ContactPoint(name, robot, name, contactNormal, mu, fMin, fMax) contacts[i].setKp(kp_contact * matlib.ones(3).T) contacts[i].setKd(2.0 * np.sqrt(kp_contact) * matlib.ones(3).T) H_rf_ref = robot.framePosition(data, robot.model().getFrameId(name)) contacts[i].setReference(H_rf_ref) contacts[i].useLocalFrame(False) invdyn.addRigidContact(contacts[i], w_forceRef, 1.0, 1)
def neglnlikehood(self): a = np.linalg.solve(self.UPsicXc.T, np.matrix(self.yc).T) b = np.linalg.solve(self.UPsicXc, a) c = ones([self.nc, 1]).T * b d = np.linalg.solve(self.UPsicXc.T, ones([self.nc, 1])) e = np.linalg.solve(self.UPsicXc, d) f = ones([self.nc, 1]).T * e self.muc = c / f # This only works if yc is transposed, then its a scalar under two layers of arrays. Correct? Not sure print('y', self.yd.T) a = np.linalg.solve(self.UPsicXe.T, self.yd) print('a', a) b = np.linalg.solve(self.UPsicXe, a) print('b', b) c = ones([self.ne, 1]) * b print('c', c) d = np.linalg.solve(self.UPsicXe.T, ones([self.ne, 1], dtype=float)) print(d) e = np.linalg.solve(self.UPsicXe, d) print(e) f = ones([self.ne, 1]).T * e print(f) self.mud = c / f a = np.linalg.solve( self.UPsicXc.T, (self.yc - ones([self.nc, 1]) * self.muc)) / self.nc b = np.linalg.solve(self.UPsicXc, a) self.SigmaSqrc = (self.yc - ones([self.nc, 1]) * self.muc).T * b print(self.ne) print(self.mud) print(self.UPsicXe.T) a = np.linalg.solve( self.UPsicXe.T, (self.yd - ones([self.ne, 1]) * self.mud)) / self.ne b = np.linalg.solve(self.UPsicXe, a) self.SigmaSqrd = (self.yd - ones([self.ne, 1]) * self.mud).T * b self.C = np.array([ self.SigmaSqrc * self.PsicXc, self.rho * self.SigmaSqrc * self.PsicXcXe, self.rho * self.SigmaSqrc * self.PsicXeXc, np.power(self.rho, 2) * self.SigmaSqrc * self.PsicXe + self.SigmaSqrd * self.PsidXe ]) np.reshape(c, [2, 2]) self.UC = np.linalg.cholesky(self.C)
def applyTransformForPoints(points, moving_res, fixed_res, R, T, C = npy.asmatrix([0, 0, 0]).T): points[:, :3] *= moving_res[:3] points[:, :3] -= C.T if T.shape[1] == 1: TT = ml.ones((points.shape[0], 1)) * T.T else: TT = T temp = ml.mat(points[:, :3]) * R + TT + ml.ones((points.shape[0], 1)) * C.T points[:, :3] = temp points[:, :3] /= fixed_res[:3] return points
def svmfit(X, y): features, samples = np.shape(X) H = np.ones((features + 1, features + 1)) H[0] = 0 H[:, 0] = 0 A = np.zeros((samples, features + 1)) for i in range(samples): A[i] = np.hstack((y[i], y[i] * X[:, i])) w = mat.ones(features + 1) w = QuadProg(np.matrix(H), mat.zeros((features + 1, 1)), [], [], np.matrix(A), mat.ones((samples, 1)), np.matrix(w).transpose()); return w
def getMfeature(self): mata = npmatrix.empty((3, 4)) # random data mata = npmatrix.zeros((3, 4)) # zeros mata = npmatrix.ones((3, 4)) # one mata = npmatrix.eye(3) # one along diagonal mata = npmatrix.eye(3, 5) # one along diagonal mata = npmatrix.identity(3) # identity square matrix mata = npmatrix.rand(3, 7) # rand data mata = npmatrix.ones((3, 1)) # one print(mata) print(mata.shape) print(mata.dtype)
def knives(dim): # returns a list of structured random row vectors if dim == 0: r = random.choice([-1, +1]) return [mat.mat(r), mat.mat(-r)] n = int(2**dim) ss = [ np.concatenate([mat.ones((1, n / 2)), -mat.ones((1, n / 2))], axis=1), np.concatenate([-mat.ones( (1, n / 2)), mat.ones((1, n / 2))], axis=1), ] for h in knives(dim - 1): ss.append(np.concatenate([h, h], axis=1)) return ss
def svmfit(X, y): features, samples = np.shape(X) H = np.ones((features + 1, features + 1)) H[0] = 0 H[:, 0] = 0 A = np.zeros((samples, features + 1)) for i in range(samples): A[i] = np.hstack((y[i], y[i] * X[:, i])) w = mat.ones(features + 1) w = QuadProg(np.matrix(H), mat.zeros((features + 1, 1)), [], [], np.matrix(A), mat.ones((samples, 1)), np.matrix(w).transpose()) return w
def neglnlikehood(self): a = np.linalg.solve(self.UPsicXc.T, np.matrix(self.yc).T) b = np.linalg.solve( self.UPsicXc, a ) c = ones([self.nc,1]).T * b d = np.linalg.solve(self.UPsicXc.T, ones([self.nc,1])) e = np.linalg.solve(self.UPsicXc, d) f = ones([self.nc,1]).T * e self.muc = c/f # This only works if yc is transposed, then its a scalar under two layers of arrays. Correct? Not sure print 'y',self.yd.T a = np.linalg.solve(self.UPsicXe.T, self.yd) print 'a',a b = np.linalg.solve(self.UPsicXe, a) print 'b', b c = ones([self.ne,1]) * b print 'c', c d = np.linalg.solve(self.UPsicXe.T, ones([self.ne,1], dtype=float)) print d e = np.linalg.solve(self.UPsicXe, d) print e f = ones([self.ne,1]).T * e print f self.mud= c/f a = np.linalg.solve(self.UPsicXc.T,(self.yc-ones([self.nc,1])*self.muc))/self.nc b = np.linalg.solve(self.UPsicXc, a) self.SigmaSqrc=(self.yc-ones([self.nc,1])*self.muc).T* b print self.ne print self.mud print self.UPsicXe.T a = np.linalg.solve(self.UPsicXe.T,(self.yd-ones([self.ne,1])*self.mud))/self.ne b = np.linalg.solve(self.UPsicXe, a) self.SigmaSqrd=(self.yd-ones([self.ne,1])*self.mud).T* b self.C=np.array([self.SigmaSqrc*self.PsicXc, self.rho*self.SigmaSqrc*self.PsicXcXe, self.rho*self.SigmaSqrc*self.PsicXeXc, np.power(self.rho,2)*self.SigmaSqrc*self.PsicXe+self.SigmaSqrd*self.PsidXe]) np.reshape(c,[2,2]) self.UC = np.linalg.cholesky(self.C)
def kernel_submatrix(self): # Cache kernel evaluations between vectors in this dataset so we don't repeat this work every # time we call Bhattacharrya X = self.X (n,d) = X.shape K = mat.zeros((n,n)) for i in xrange(n): for j in xrange(i+1): K[i,j] = self.kernel(X[i,:], X[j,:]) K[j,i] = K[i,j] Ki = mat.sum(K,1) / n k = mat.sum(K) / (n*n) Kc = K - Ki * mat.ones((1,n)) - mat.ones((n,1)) * Ki.T + k * mat.ones((n,n)) return (K, Kc)
def test_conjgrad_solver(n): H = linalg.hilbert(n) x0 = matlib.ones([n, 1]) b = H @ x0 x = [0, 1] y1 = [] y2 = [] for xi in tqdm(x): x1, niter = conjgrad(H, b, ind=xi, eps=1e-15) y1.append(linalg.norm(x0 - x1, ord=np.inf)) y2.append(niter) sleep(0.01) fig, left_axis = plt.subplots() right_axis = left_axis.twinx() plt.title("Conjugate gradient results for "+ \ "$H_{"+str(n)+"}\bf{x}=\bf{b}$") left_axis.plot(x, y1, 'ro-') left_axis.set_xlabel("Preprocessing index") left_axis.set_ylabel("Infinite-norm error", color='r') left_axis.tick_params(axis='y', colors='r') right_axis.plot(x, y2, 'bo-') right_axis.set_xlabel("Same") right_axis.set_ylabel("Iteration step", color='b') right_axis.tick_params(axis='y', colors='b') plt.show()
def vel_source_matrix(Qab, rl, phid): velsl = zero_matrix_vector(Qab.shape, dtype=float) velsl.y = -Qab faco = ones(Qab.shape, dtype=float) faco[rl.z != 0.0] = -1.0 velsl.z = multiply(faco, phid) return velsl
def kernel_matrix(X, kernel, n1, n2): (n, d) = X.shape assert n == n1 + n2 K = mat.zeros((n, n)) for i in xrange(n): for j in xrange(i + 1): K[i, j] = kernel(X[i, :], X[j, :]) K[j, i] = K[i, j] U1 = mat.sum(K[0:n1, :], 0) / n1 U2 = mat.sum(K[n1:n, :], 0) / n2 U1m = mat.tile(U1, (n1, 1)) U2m = mat.tile(U2, (n2, 1)) U = mat.bmat('U1m; U2m') m1m1 = mat.sum(K[0:n1, 0:n1]) / (n1 * n1) m1m2 = mat.sum(K[0:n1, n1:n]) / (n1 * n2) m2m2 = mat.sum(K[n1:n, n1:n]) / (n2 * n2) mumu = mat.zeros((n, n)) mumu[0:n1, 0:n1] = m1m1 mumu[0:n1, n1:n] = m1m2 mumu[n1:n, 0:n1] = m1m2 mumu[n1:n, n1:n] = m2m2 Kcu = K - U Kuc = Kcu.T N = mat.ones((n, n)) / n Kc = K - U - U.T + mumu return (K, Kuc, Kc)
def kernel_submatrix(self): # Cache kernel evaluations between vectors in this dataset so we don't repeat this work every # time we call Bhattacharrya X = self.X (n, d) = X.shape K = mat.zeros((n, n)) for i in xrange(n): for j in xrange(i + 1): K[i, j] = self.kernel(X[i, :], X[j, :]) K[j, i] = K[i, j] Ki = mat.sum(K, 1) / n k = mat.sum(K) / (n * n) Kc = K - Ki * mat.ones((1, n)) - mat.ones( (n, 1)) * Ki.T + k * mat.ones((n, n)) return (K, Kc)
def test_simpleit_solver(n): H = linalg.hilbert(n) x0 = matlib.ones([n, 1]) b = H @ x0 x = np.arange(0.1, 2.0, 0.1) y1 = [] y2 = [] #x1, niter = jacobi(H,b) #print(x1,niter) for xi in tqdm(x): x1, niter = gs_sor(H, b, omg=xi, eps=1e-15) y1.append(math.log(linalg.norm(x0 - x1, ord=np.inf), 10)) y2.append(niter) sleep(0.01) fig, left_axis = plt.subplots() right_axis = left_axis.twinx() plt.title("SOR results for $H_{" + str(n) + "}\bf{x}=\bf{b}$") left_axis.plot(x, y1, 'ro-') left_axis.set_xlabel("Relaxation coefficient") left_axis.set_ylabel("log(Infinite-norm error)", color='r') left_axis.tick_params(axis='y', colors='r') right_axis.plot(x, y2, 'bo-') right_axis.set_xlabel("Same") right_axis.set_ylabel("Iteration step", color='b') right_axis.tick_params(axis='y', colors='b') plt.show()
def doublet_velocity_potentials(self, pnts: MatrixVector, extraout: bool = False, sgnz: matrix = None, factor: bool = True, betx: float = 1.0): rls = self.points_to_local(pnts, betx=betx) absx = absolute(rls.x) rls.x[absx < tol] = 0.0 absy = absolute(rls.y) rls.y[absy < tol] = 0.0 absz = absolute(rls.z) rls.z[absz < tol] = 0.0 if sgnz is None: sgnz = ones(rls.shape, float) sgnz[rls.z <= 0.0] = -1.0 avs = rls - self.grdal phida, ams = phi_doublet_matrix(avs, rls, sgnz) bvs = rls - self.grdbl phidb, bms = phi_doublet_matrix(bvs, rls, sgnz) phids = phida - phidb if factor: phids = phids / fourPi if extraout: return phids, rls, avs, ams, bvs, bms else: return phids
def CanonicalFromDPH2(alpha, A, prec=1e-14): """ Returns the canonical form of an order-2 discrete phase-type distribution. Parameters ---------- alpha : matrix, shape (1,2) Initial vector of the discrete phase-type distribution A : matrix, shape (2,2) Transition probability matrix of the discrete phase-type distribution prec : double, optional Numerical precision for checking the input, default value is 1e-14 Returns ------- beta : matrix, shape (1,2) The initial probability vector of the canonical form B : matrix, shape (2,2) Transition probability matrix of the canonical form """ if butools.checkInput and not CheckMGRepresentation(alpha, A, prec): raise Exception( "CanonicalFromDPH2: Input is not a valid DPH representation!") if butools.checkInput and (A.shape[0] != 2 or A.shape[1] != 2): raise Exception("CanonicalFromDPH2: Dimension must be 2!") ev = la.eigvals(A) ix = np.argsort(-np.abs(np.real(ev))) lambd = ev[ix] e = ml.ones((2, 1)) p1 = (alpha * (e - A * e))[0, 0] if lambd[0] > 0 and lambd[1] > 0 and lambd[0] != lambd[1]: d1 = (1 - lambd[0]) * (1 - p1 - lambd[1]) / (lambd[0] - lambd[1]) d2 = p1 - d1 beta = ml.matrix([[ d1 * (lambd[0] - lambd[1]) / ((1 - lambd[0]) * (1 - lambd[1])), (d1 + d2) / (1 - lambd[1]) ]]) B = ml.matrix([[lambd[0], 1 - lambd[0]], [0, lambd[1]]]) elif lambd[0] > 0 and lambd[0] == lambd[1]: d2 = p1 d1 = (1 - lambd[0]) * (1 - d2 - lambd[0]) / lambd[0] beta = ml.matrix( [[d1 * lambd[0] / (1 - lambd[0])**2, d2 / (1 - lambd[0])]]) B = ml.matrix([[lambd[0], 1 - lambd[0]], [0, lambd[0]]]) elif lambd[0] > 0: d1 = (1 - lambd[0]) * (1 - p1 - lambd[1]) / (lambd[0] - lambd[1]) d2 = p1 - d1 beta = ml.matrix([[(d1 * lambd[0] + d2 * lambd[1]) / ((1 - lambd[0]) * (1 - lambd[1])), (d1 + d2) * (1 - lambd[0] - lambd[1]) / ((1 - lambd[0]) * (1 - lambd[1]))]]) B = ml.matrix([[lambd[0] + lambd[1], 1 - lambd[0] - lambd[1]], [lambd[0] * lambd[1] / (lambd[0] + lambd[1] - 1), 0]]) return (np.real(beta), np.real(B))
def applyTransform(points, para): T = ml.mat(para[:3]).T R = ml.mat(para[3:].reshape(3, 3)).T.I result = npy.array(points) result[:, :3] = ml.mat(points[:, :3]) * R + ml.ones( (points.shape[0], 1)) * T.T return result
def loglikelihood(self, obs): # compute the log likelihood given a sequence of obs t_mat = npmat.matrix(self.t_mat) # use alpha alpha = npmat.matrix((self.pi_vec * self.z_mat[obs[0], :])[:,np.newaxis]) # print('self.z_mat[obs[0], :]: '+ str(self.z_mat[obs[0], :])) # print('self.pi_vec: '+ str(self.pi_vec)) # print('self.pi_vec * self.z_mat[obs[0], :]: '+ str(self.pi_vec * self.z_mat[obs[0], :])) # print('alpha: '+ str(alpha)) log_coef = 0 for i in range(1,len(obs)): alpha = npmat.matrix(((t_mat * alpha).getA()[:,0] * self.z_mat[obs[i], :])[:,np.newaxis]) asum = alpha.sum() alpha /= asum log_coef += np.log(asum) alpha_ll = log_coef + np.log(alpha.sum()) # use beta if False: beta = npmat.ones((t_mat.shape[0], 1)) log_coef = 0 for i in range(len(obs)-2,-1,-1): # print('self.z_mat[obs[i+1], :]: ' + str(self.z_mat[obs[i+1], :])) # print('beta.getA()[0]: ' + str(beta.getA()[:,0])) # print('self.z_mat[obs[i+1], :] * beta.getA()[:,0]: ' + str(self.z_mat[obs[i+1], :] * beta.getA()[:,0])) # print('npmat.matrix(result): ' + str(npmat.matrix((self.z_mat[obs[i+1], :] * beta.getA()[:,0])[:,np.newaxis]))) # print('t_mat.getT(): ' + str(t_mat.getT())) beta = t_mat.getT() * npmat.matrix((self.z_mat[obs[i+1], :] * beta.getA()[:,0])[:,np.newaxis]) bsum = beta.sum() beta /= bsum log_coef += np.log(bsum) beta_ll = log_coef + np.log(np.sum(beta.getA()[0] * self.pi_vec * self.z_mat[obs[0],:])) # print('alpha_ll: ' + str(alpha_ll)) # print('beta_ll: ' + str(beta_ll)) return alpha_ll
def applyTransformForPoints(points, moving_res, fixed_res, R, T, C=npy.asmatrix([0, 0, 0]).T): points[:, :3] *= moving_res[:3] points[:, :3] -= C.T if T.shape[1] == 1: TT = ml.ones((points.shape[0], 1)) * T.T else: TT = T temp = ml.mat(points[:, :3]) * R + TT + ml.ones((points.shape[0], 1)) * C.T points[:, :3] = temp points[:, :3] /= fixed_res[:3] return points
def doublet_velocity_potentials(self, pnts: MatrixVector, extraout: bool = False, sgnz: matrix = None, factor: bool = True, betx: float = 1.0): rls = self.points_to_local(pnts, betx=betx) absx = absolute(rls.x) rls.x[absx < tol] = 0.0 absy = absolute(rls.y) rls.y[absy < tol] = 0.0 absz = absolute(rls.z) rls.z[absz < tol] = 0.0 if sgnz is None: sgnz = ones(rls.shape, float) sgnz[rls.z <= 0.0] = -1.0 ovs = rls - self.grdol phido, oms = phi_doublet_matrix(ovs, rls, sgnz) phidt = phi_trailing_doublet_matrix(rls, sgnz, self.faco) phid = phido * self.faco + phidt if factor: phid = phid / fourPi if extraout: output = phid, rls, ovs, oms else: output = phid return output
def kernel_matrix(X, kernel, n1, n2): (n, d) = X.shape assert n == n1 + n2 K = mat.zeros((n,n)) for i in xrange(n): for j in xrange(i+1): K[i,j] = kernel(X[i,:], X[j,:]) K[j,i] = K[i,j] U1 = mat.sum(K[0:n1,:],0) / n1 U2 = mat.sum(K[n1:n,:],0) / n2 U1m = mat.tile(U1, (n1,1)) U2m = mat.tile(U2, (n2,1)) U = mat.bmat('U1m; U2m') m1m1 = mat.sum(K[0:n1, 0:n1]) / (n1*n1) m1m2 = mat.sum(K[0:n1, n1:n]) / (n1*n2) m2m2 = mat.sum(K[n1:n, n1:n]) / (n2*n2) mumu = mat.zeros((n,n)) mumu[0:n1, 0:n1] = m1m1 mumu[0:n1, n1:n] = m1m2 mumu[n1:n, 0:n1] = m1m2 mumu[n1:n, n1:n] = m2m2 Kcu = K - U Kuc = Kcu.T N = mat.ones((n,n))/n Kc = K - U - U.T + mumu return (K, Kuc, Kc)
def em_step(num_states, num_obs, pi_vec, z_mat, t_mat, obs_all): # given initial parameters, run em from the obs # obs are 2d with each row being a trajectory # returns estimated observation and transition matrices num_steps = obs_all.shape[1] t_mat = npmat.matrix(t_mat) gamma_sum = np.zeros((num_states,)) xi_sum = np.zeros((num_states, num_states)) obs_sum = np.zeros((num_obs, num_states)) for t in range(obs_all.shape[0]): obs = obs_all[t, :] # compute alpha alpha = npmat.zeros((num_states, num_steps)) alpha[:, 0] = npmat.matrix((pi_vec * z_mat[obs[0], :])[:, np.newaxis]) for i in range(1, len(obs)): alpha[:, i] = npmat.matrix(((t_mat * alpha[:, i - 1]).getA()[:, 0] * z_mat[obs[i], :])[:, np.newaxis]) asum = alpha[:, i].sum() alpha[:, i] /= asum # print('alpha\n' + str(alpha)) # compute beta beta = npmat.zeros((num_states, num_steps)) beta[:, num_steps - 1] = npmat.ones((num_states, 1)) for i in range(len(obs) - 2, -1, -1): beta[:, i] = t_mat.getT() * npmat.matrix( (z_mat[obs[i + 1], :] * beta[:, i + 1].getA()[:, 0])[:, np.newaxis]) bsum = beta[:, i].sum() beta[:, i] /= bsum # print(beta) # compute gamma gamma = alpha.getA() * beta.getA() gamma = gamma / (gamma.sum(axis=0)[np.newaxis, :]) # print(gamma) # compute xi (transposed from the paper) xi = np.zeros((num_states, num_states, num_steps - 1)) for i in range(num_steps - 1): xi[:, :, i] = np.transpose(alpha[:, i].getA()) * t_mat.getA() * (z_mat[obs[i + 1], :] * beta[:, i + 1].getA()[0])[:, np.newaxis] xsum = xi[:, :, i].sum() xi[:, :, i] /= xsum # print('xi[:,:,i]' + str(xi[:,:,i])) # print('np.transpose(alpha[:,i].getA()): ' + str(np.transpose(alpha[:,i].getA()))) # print('t_mat: ' + str(t_mat)) # print('result of *: ' + str(np.transpose(alpha[:,i].getA()) * t_mat.getA())) # add to the sums gamma_sum += gamma.sum(axis=1) xi_sum += xi.sum(axis=2) for z in range(num_obs): obs_sum[z, :] += gamma[:, obs == z].sum(axis=1) # print('gamma_sum\n' + str(gamma_sum)) # print('xi_sum\n' + str(xi_sum)) # print('obs_sum\n' + str(obs_sum)) # finally compute estimates est_z_mat = obs_sum / obs_sum.sum(axis=0)[np.newaxis, :] est_t_mat = xi_sum / xi_sum.sum(axis=0)[np.newaxis, :] return est_z_mat, est_t_mat;
def predict(self, X, *args, **kwargs): m = X.shape[0] Z = None S = None A = numpy.concatenate((matlib.ones((m, 1)), X), axis=1) is_first_layer = True for Theta_index in range(len(self._Theta)): if is_first_layer: is_first_layer = False else: A = numpy.concatenate((matlib.ones((m, 1)), Z), axis=1) Z = A * self._Theta[Theta_index] S = sigmoid(Z) return S > 0.5
def make_y_X_stack(self): VAR_attr = self.VAR_attr veclen = VAR_attr['veclen'] laglen = VAR_attr['laglen'] nuofobs = VAR_attr['nuofobs'] avobs = VAR_attr['avobs'] useconst = VAR_attr['useconst'] data = self.data y = data[laglen:,:] X = MAT.zeros((avobs,veclen*laglen)) for x1 in range(0,laglen,1): X[:,x1*veclen:(x1+1)*veclen] = data[(laglen-1)-x1:(nuofobs-1)-x1,:] if self.VAR_attr['useconst'] == 1: X = N.hstack((MAT.ones((avobs,1)),X[:,:])) try: self.ols_results['y'] = y self.ols_results['X'] = X except: self.ols() self.ols_results['y'] = y self.ols_results['X'] = X if useconst == 0: y_stack = MAT.zeros((avobs,veclen*laglen)) y_stack_1 = MAT.zeros((avobs,veclen*laglen)) y_stack[:,0:veclen] = y y_stack_1 = X y_stack = N.hstack((y_stack[:,0:veclen],y_stack_1[:,0:veclen*(laglen-1)])) self.ols_comp_results['X'] = y_stack_1 self.ols_comp_results['y'] = y_stack else: y_stack = MAT.zeros((avobs,veclen*laglen)) y_stack_1 = MAT.zeros((avobs,1+veclen*laglen)) y_stack_1[:,0] = MAT.ones((avobs,1))[:,0] y_stack[:,0:veclen] = y y_stack_1 = X y_stack = N.hstack((y_stack[:,0:veclen],y_stack_1[:,1:veclen*(laglen-1)+1])) self.ols_comp_results['X'] = y_stack_1 self.ols_comp_results['y'] = y_stack
def sign_local_z(self, pnts: MatrixVector, betx: float = 1.0): vecs = pnts - self.pnto nrm = self.nrm if betx != 1.0: vecs.x = vecs.x / betx nrm = Vector(self.nrm.x / betx, self.nrm.y, self.nrm.z) locz = vecs * nrm sgnz = ones(locz.shape, float) sgnz[locz <= 0.0] = -1.0 return sgnz
def trainNB0(trainMatrix, trainCategory): numTrainDocs = len(trainMatrix) # Number of training sentence numWords = len(trainMatrix[0]) # Number of word in sentence pAbusive = sum(trainCategory) / float( numTrainDocs) # Probability of abusive sentence in all sentences p0Num = ones(numWords) p1Num = ones(numWords) #The reason why use 'ones', not 'zeros' is in P62 p0Denom = 2.0 p1Denom = 2.0 for i in range(numTrainDocs): if trainCategory[i] == 1: p1Num += trainMatrix[i] p1Denom += sum(trainMatrix[i]) else: p0Num += trainMatrix[i] p0Denom += sum(trainMatrix[i]) p1Vect = p1Num / p1Denom p0Vect = p0Num / p0Denom return p0Vect, p1Vect, pAbusive
def point(x, y): """ 2D affine point vector used in 2D spatial transformations. To use, call the matrix '*' operator. """ m = ones((3, 1)) m[0] = x m[1] = y return m
def applyRigidTransformOnPoints(points, res, T): # Y = XT X = ml.ones([points.shape[0], 4], dtype=npy.float32) tmp = points.copy() tmp[:, :3] *= res X[:, :3] = tmp[:, :3] Y = X * T result_points = npy.array(points.copy()) result_points[:, :3] = Y[:, :3] result_points[:, :3] /= res return result_points
def KFDA_J(self, K, N_p, N_n, q=0): if q==0: q = N_p + N_n a = Nmat.ones([N_p + N_n, 1]) a[0:N_p] = 1 / N_p a[N_p:] = -1 / N_n A = Nmat.matrix([np.diag(1 / np.sqrt(N_p) * (Nmat.identity(N_p) - 1 / N_p * Nmat.ones([N_p, N_p]))), \ np.diag(1 / np.sqrt(N_n) * (Nmat.identity(N_n) - 1 / N_n * Nmat.ones([N_n, N_n])))]) Q = K tmp = 1e8 * Nmat.identity(N_p + N_n) - 1e8 * A * Q * LA.inv(1e8 * Nmat.identity(q) + Q.T * A * A(Q)) * Q.T * A J = 1/1e-8 * (a.T * K * a - a.T * K * A * tmp * A * K * a) return J
def applyRigidTransformOnPoints(points, res, T): # Y = XT X = ml.ones([points.shape[0], 4], dtype = npy.float32) tmp = points.copy() tmp[:, :3] *= res X[:, :3] = tmp[:, :3] Y = X * T result_points = npy.array(points.copy()) result_points[:, :3] = Y[:, :3] result_points[:, :3] /= res return result_points
def __new__(cls, c): """ """ c = c.view(matlib.matrix).reshape(1, -1) T = matlib.vstack(( matlib.hstack((matlib.identity(c.size), c)), matlib.hstack((matlib.zeros(c.size), matlib.ones(1))), )) return super().__new__(cls, T)
def KFDA_J(self,K,N_p,N_n,q=0): #calculate the kfda J #N_p:the number of the positive feature #N_n:the number of the negtive feature if q==0: q=N_p+N_q a=Nmat.ones([N_p+N_n,1]) a[0:N_p]=1/N_p a[N_p:]=-1/N_n A=Nmat.matrix([np.diag(1/np.sqrt(N_p)*(Nmat.identity(N_p)-1/N_p*Nmat.ones([N_p,N_p]))),\ np.diag(1/np.sqrt(N_n)*(Nmat.identity(N_n)-1/N_n*Nmat.ones([N_n,N_n])))]) # Q=Clustr_kmeans(K,q) # tmp=np.linaly.inv(1e-8*Nmat.identity(N_p+N_n)+A*K*A) tmp=1e8*Nmat.identity(N_p+N_n)-1e8*A*Q*LA.inv(1e8*Nmat.identity(q)+Q.T*A*A(Q))*Q.T*A J=1/(1e-8)*(a.T*K*a-a.T*K*A*tmp*A*K*a) return J
def evalfun (oH, k=0): Ones = ml.ones(oH[0].shape) if k%2 == 0: dist = np.min(oH[0]) for oHk in oH: dist = min(dist, np.min(oHk), np.min(Ones-oHk)) return -dist else: dist = np.sum(oH[0][oH[0]<0]) for oHk in oH: dist += min(np.sum(oHk[oHk<0]), np.sum(oHk[Ones-oHk<0])) return -dist
def __call__(self, x, z=[], diag=False): if x.shape[0] == 0: return np.zeros((0, 0)) if diag: return self.sf2*np.ones((x.shape[0], 1)) sx = x*self.covd if z == []: K = np.asmatrix(ssd.squareform(ssd.pdist(sx, 'sqeuclidean'))) else: sz = z*self.covd K = np.asmatrix(ssd.cdist(sx, sz, 'sqeuclidean')) K = self.sf2*np.exp(-K/2) return K
def CanonicalFromDPH2 (alpha,A,prec=1e-14): """ Returns the canonical form of an order-2 discrete phase-type distribution. Parameters ---------- alpha : matrix, shape (1,2) Initial vector of the discrete phase-type distribution A : matrix, shape (2,2) Transition probability matrix of the discrete phase-type distribution prec : double, optional Numerical precision for checking the input, default value is 1e-14 Returns ------- beta : matrix, shape (1,2) The initial probability vector of the canonical form B : matrix, shape (2,2) Transition probability matrix of the canonical form """ if butools.checkInput and not CheckMGRepresentation (alpha, A, prec): raise Exception("CanonicalFromDPH2: Input is not a valid DPH representation!") if butools.checkInput and (A.shape[0]!=2 or A.shape[1]!=2): raise Exception("CanonicalFromDPH2: Dimension must be 2!") ev = la.eigvals(A) ix = np.argsort(-np.abs(np.real(ev))) lambd = ev[ix] e=ml.ones((2,1)) p1=(alpha*(e-A*e))[0,0] if lambd[0]>0 and lambd[1]>0 and lambd[0] != lambd[1]: d1=(1-lambd[0])*(1-p1-lambd[1])/(lambd[0]-lambd[1]) d2=p1-d1 beta=ml.matrix([[d1*(lambd[0]-lambd[1])/((1-lambd[0])*(1-lambd[1])),(d1+d2)/(1-lambd[1])]]) B=ml.matrix([[lambd[0],1-lambd[0]],[0,lambd[1]]]) elif lambd[0]>0 and lambd[0]==lambd[1]: d2=p1 d1=(1-lambd[0])*(1-d2-lambd[0])/lambd[0] beta=ml.matrix([[d1*lambd[0]/(1-lambd[0])**2,d2/(1-lambd[0])]]) B=ml.matrix([[lambd[0],1-lambd[0]],[0,lambd[0]]]) elif lambd[0]>0: d1=(1-lambd[0])*(1-p1-lambd[1])/(lambd[0]-lambd[1]) d2=p1-d1 beta=ml.matrix([[(d1*lambd[0]+d2*lambd[1])/((1-lambd[0])*(1-lambd[1])),(d1+d2)*(1-lambd[0]-lambd[1])/((1-lambd[0])*(1-lambd[1]))]]) B=ml.matrix([[lambd[0]+lambd[1],1-lambd[0]-lambd[1]],[lambd[0]*lambd[1]/(lambd[0]+lambd[1]-1),0]]) return (np.real(beta),np.real(B))
def __init__(self, A=np.matrix(0.9), B=np.matrix(1.), Z1=np.matrix(1.), Z2=np.matrix(1.), noise_cov=np.matrix(.01), seed=1): ''' A,B are some Matrices here if state is mx1 then A is mxm, B is mxn then the u should be nx1 Z1,Z2 are some positive semi-definite weight matrices mxm or scala that determines the trade-off between keeping state small and keeping action small. ''' super(LQREnv, self).__init__() self.m = A.shape[0] assert B.shape[0] == A.shape[1] self.n = B.shape[1] if not np.isscalar(Z1): Z1.shape[0] == A.shape[0] if not np.isscalar(Z2): Z2.shape == A.shape self.A = A self.B = B self.Z1 = Z1 self.Z2 = Z2 self.state = None # noisy self.noise_mu = np.matrix(np.zeros(self.m).reshape(self.m, 1)) self.noise_cov = noise_cov self.rng = self.set_seed(seed) high = mb.ones((self.n, 1)) * np.inf # TODO: Action now is continous self.action_space = Box(low=-high, high=high, dtype=np.float32) high = mb.ones((self.m, 1)) * np.inf # print(self.action_space) self.observation_space = Box(low=-high, high=high, dtype=np.float32)
def gradAscent(data,label,labelSet): hmat = zeros((data.shape[0],len(labelSet) - 1)).tolist() # print "hmat[2][1]",hmat[2][1] i = 0 # print "ge zhong changdu",len(labelSet) - 1,data.shape[0] for k in range(len(labelSet) - 1): for j in range(data.shape[0]): if(label[j] == labelSet[k]): hmat[j][k] = 1 iteration = 1 error = 0.00001 m,n = shape(data) labelNum = len(labelSet) - 1 if(labelNum >= 2): weights = ones((n,labelNum)) else: weights = ones((n,1)) # for i in range(iteration): for i in range(labelNum): diff = 1 hmat = mat(hmat) while(diff > error): if(labelNum == 1): h = sigMoid(data * weights[:,i]) h = mat(h) deri = mat(label).transpose() - h ###11*1 else: h = fakeSigMoid(data * weights) h = mat(h) deri = hmat[:,i] - h[:,i] ###11*1 # cichu hai zhengchang formal = copy.deepcopy(weights[:,i]) weights[:,i] = weights[:,i] + alpha * data.transpose() * deri ####梯度下降法目标函数取最小值,所以此处为+ diff = abs(formal.transpose() * formal - weights[:,i].transpose() * weights[:,i]) print "diff = ",diff return weights
def PageRank(A,N,m,id2p,top,p_f): E = ones((N,N)); MM = (1.0-m)*A + (m/N)*E; #MM = A; x = MM * (1.0/N) * ones((N,1)); x = eigenCalc(x, MM,N,200) for i in range(0,N): top[i] = x[i][0,0] import operator s_t = sorted(top.iteritems(), key=operator.itemgetter(1)) s_t.reverse(); #print "sorted_top = ", sorted_top; f = open('listwithranks.txt', 'w') k = 0 for protein in s_t: s = str(id2p[protein[0]]) + " " + str(protein[1]) + " flag " + str(p_f[protein[0]]) print >> f, s f.close() return s_t
def inf(self, x, meanonly=False): x = np.asmatrix(x) assert x.shape[1] == self.d n = x.shape[0] # Handle empty test set if n == 0: return (np.zeros((0, 1)), np.zeros((0, 1))) ms = self.kernel.mean*np.ones((n, 1)) Kbb = self.kernel(x, diag=True) # Handle empty training set if len(self) == 0: return (ms, np.asmatrix(np.diag(Kbb)).T) Kba = self.kernel(x, self.x) m = self.kernel.mean*np.ones((len(self), 1)) fm = ms + Kba*scipy.linalg.cho_solve((self.L, True), self.y - m, overwrite_b=True) if meanonly: return fm else: W = scipy.linalg.cho_solve((self.L, True), Kba.T) fv = np.asmatrix(Kbb - np.sum(np.multiply(Kba.T, W), axis=0).T) # W = np.asmatrix(scipy.linalg.solve(self.L, Kba.T, lower=True)) # fv = np.asmatrix(Kbb - np.sum(np.power(W, 2), axis=0).T) return (fm, fv)
def startComputation_np(m, N, e_limit, maxIt): x = matlib.ones((N,1)) start = time.clock() itCnt = 0 success = False while itCnt < maxIt and not success: itCnt += 1 y = m * x y_max = y.max() x_new = y / y_max e_k = vectorChange_np(N, x, x_new) x = x_new if e_k <= e_limit : success = True showResult(success, N, y_max, x.tolist(), time.clock()-start, itCnt)
def MinimalRepFromMRAP (H, how="obscont", precision=1e-12): """ Returns the minimal representation of a marked rational arrival process. Parameters ---------- H : list of matrices of shape (M,M) The list of H0, H1, ..., HK matrices of the marked rational arrival process how : {"obs", "cont", "obscont"}, optional Determines how the representation is minimized. "cont" means controllability, "obs" means observability, "obscont" means that the rational arrival process is minimized in both respects. Default value is "obscont". precision : double, optional Precision used by the Staircase algorithm. The default value is 1e-12. Returns ------- D : list of matrices of shape (M,M) The D0, D1, ..., DK matrices of the minimal representation References ---------- .. [1] P. Buchholz, M. Telek, "On minimal representation of rational arrival processes." Madrid Conference on Qeueuing theory (MCQT), June 2010. """ if butools.checkInput and not CheckMRAPRepresentation (H): raise Exception("MinimalRepFromMRAP: Input is not a valid MRAP representation!") if how=="cont": B, n = MStaircase (H, ml.ones((H[0].shape[0],1)), precision) return [(la.inv(B)*Hk*B)[0:n,0:n] for Hk in H] elif how=="obs": alpha, A = MarginalDistributionFromMRAP (H) G = [Hk.T for Hk in H] B, n = MStaircase (G, alpha.T, precision) return [(la.inv(B)*Hk*B)[0:n,0:n] for Hk in H] elif how=="obscont": D = MinimalRepFromMRAP(H, "cont", precision) return MinimalRepFromMRAP(D, "obs", precision)
def __new__(cls, m, n): """ """ if not all(( isinstance(m, int), isinstance(n, int), )): raise ValueError data = matlib.hstack([ matlib.vstack(( matlib.hstack((matlib.identity(n, dtype=int), matlib.matrix(p, dtype=int).T)), matlib.hstack((matlib.matrix(p, dtype=int), matlib.ones(1))), )) for p in product(range(m), repeat=n) ]) return super().__new__(cls, data, dtype=int).view(cls)
def kernel_supermatrix(self, i, j): kernel = self.kernel D1 = self.datasets[i] D2 = self.datasets[j] X1 = D1.X X2 = D2.X (n1, d) = X1.shape (n2, d) = X2.shape n = n1 + n2 X = mat.bmat('X1; X2') K1 = D1.K K2 = D2.K K = mat.zeros((n,n)) K[0:n1, 0:n1] = K1 K[n1:n, n1:n] = K2 for i in xrange(n1): for j in xrange(n1, n): K[i,j] = kernel(X[i,:], X[j,:]) K[j,i] = K[i,j] # Inelegant - improve later U1 = mat.sum(K[0:n1,:],0) / n1 U2 = mat.sum(K[n1:n,:],0) / n2 U1m = mat.tile(U1, (n1,1)) U2m = mat.tile(U2, (n2,1)) U = mat.bmat('U1m; U2m') m1m1 = mat.sum(K[0:n1, 0:n1]) / (n1*n1) m1m2 = mat.sum(K[0:n1, n1:n]) / (n1*n2) m2m2 = mat.sum(K[n1:n, n1:n]) / (n2*n2) mumu = mat.zeros((n,n)) mumu[0:n1, 0:n1] = m1m1 mumu[0:n1, n1:n] = m1m2 mumu[n1:n, 0:n1] = m1m2 mumu[n1:n, n1:n] = m2m2 Kcu = K - U Kuc = Kcu.T N = mat.ones((n,n))/n Kc = K - U - U.T + mumu return (K, Kuc, Kc)
def __init__(self, Xc, yc, Xe, ye): # Create the data arrays self.Xc = np.atleast_2d(Xc).T self.yc = yc self.nc = self.Xc.shape[0] self.Xe = np.atleast_2d(Xe).T self.ye = ye self.ne = self.Xe.shape[0] # rho regression parameter self.rho = 1.9961 self.reorder_data() # self.traincheap() self.k = self.Xc.shape[1] # if self.Xe.shape[1] != self.Xc.shape[1]: # print 'Xc and Xe must have the same number of design variables. Fatal error -- Exiting...' # exit() # Configure the hyperparameter arrays self.thetad = np.ones(self.k) self.thetac = None # self.thetac = self.kc.theta self.pd = np.ones(self.k) * 2. # self.pc = self.kc.pl self.pc = np.ones(self.k) * 2. # Matrix Operations self.one=ones([self.ne+self.nc,1]) self.y=[self.yc, self.ye] print 'here1'
def applyTransform(points, para): T = ml.mat(para[:3]).T; R = ml.mat(para[3:].reshape(3, 3)).T.I; result = npy.array(points) result[:, :3] = ml.mat(points[:, :3]) * R + ml.ones((points.shape[0], 1)) * T.T return result
def MinimalRepFromME (alpha, A, how="moment", precision=1e-12): """ Returns the minimal representation of the given ME distribution. Parameters ---------- alpha : vector, shape (1,M) The initial vector of the matrix-exponential distribution. A : matrix, shape (M,M) The matrix parameter of the matrix-exponential distribution. how : {"obs", "cont", "obscont", "moment"}, optional Determines how the representation is minimized. Possibilities: 'obs': observability, 'cont': controllability, 'obscont': the minimum of observability and controllability order, 'moment': moment order (which is the default). precision : double, optional Precision used by the Staircase algorithm. The default value is 1e-12. Returns ------- beta : vector, shape (1,N) The initial vector of the minimal representation B : matrix, shape (N,N) The matrix parameter of the minimal representation References ---------- .. [1] P. Buchholz, M. Telek, "On minimal representation of rational arrival processes." Madrid Conference on Qeueuing theory (MCQT), June 2010. """ if butools.checkInput and not CheckMERepresentation (alpha, A): raise Exception("MinimalRepFromME: Input is not a valid ME representation!") if how=="cont": H0 = A H1 = np.sum(-A,1) * alpha B, n = MStaircase ([H0, H1], ml.ones((A.shape[0],1)), precision) return ((alpha*B)[0,0:n], (la.inv(B)*A*B)[0:n,0:n]) elif how=="obs": H0 = A H1 = np.sum(-A,1) * alpha G = [H0.T,H1.T] B, n = MStaircase (G, alpha.T, precision) return ((alpha*B)[:,0:n], (la.inv(B)*A*B)[0:n,0:n]) elif how=="obscont": alphav, Av = MinimalRepFromME (alpha, A, "cont", precision) return MinimalRepFromME (alphav, Av, "obs", precision) elif how=="moment": N = MEOrder (alpha, A, "moment", precision) moms = MomentsFromME (alpha, A, 2*N-1) return MEFromMoments (moms)
def setWidgetView(self, widget, color = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]): super(SurfaceView, self).setWidgetView(widget) if type(self.parent) is MdiChildRegistration: point_array_move = self.parent.getData('move').pointSet point_data_move = npy.array(point_array_move.getData('Contour')) point_data_result = npy.array(point_data_move) if point_data_result is None or not point_data_result.shape[0]: return self.spacing_mov = self.parent.getData('move').getResolution().tolist() self.spacing = self.parent.getData().getResolution().tolist() para = npy.array(self.parent.getData().getInfo().getData('transform')) R = ml.mat(para[:9].reshape(3, 3)) T = ml.mat(para[9:12].reshape(3, 1)) T = R.I * T T = -T point_data_result[:, :3] *= self.spacing_mov[:3] point_data_result[:, :3] = ml.mat(point_data_result[:, :3]) * R + ml.ones((point_data_result.shape[0], 1)) * T.T point_data_result[:, :3] /= self.spacing[:3] else: point_array_result = self.parent.getData().pointSet point_data_result = npy.array(point_array_result.getData('Contour')) point_array_move = point_array_result point_data_move = npy.array(point_array_move.getData('Contour')) zmin = int(npy.min(point_data_move[:, 2]) + 0.5) zmax = int(npy.max(point_data_move[:, 2]) + 0.5) self.spacing = self.parent.getData().getResolution().tolist() self.spacing = [float(x) / self.spacing[-1] for x in self.spacing] point_data_result[:, :2] *= self.spacing[:2] self.renderer = vtk.vtkRenderer() self.render_window = widget.GetRenderWindow() self.render_window.AddRenderer(self.renderer) self.window_interactor = vtk.vtkRenderWindowInteractor() self.render_window.SetInteractor(self.window_interactor) self.contours = [] self.delaunay3D = [] self.delaunayMapper = [] self.surface_actor = [] for cnt in range(3): self.contours.append(vtk.vtkPolyData()) self.delaunay3D.append(vtk.vtkDelaunay3D()) self.delaunayMapper.append(vtk.vtkDataSetMapper()) self.surface_actor.append(vtk.vtkActor()) point_result = point_data_result[npy.where(npy.round(point_data_result[:, -1]) == cnt)] point_move = point_data_move[npy.where(npy.round(point_data_move[:, -1]) == cnt)] if not point_result.shape[0]: continue self.cells = vtk.vtkCellArray() self.points = vtk.vtkPoints() l = 0 for i in range(zmin, zmax + 1): data = point_result[npy.where(npy.round(point_move[:, 2]) == i)] if data is not None: if data.shape[0] == 0: continue count = data.shape[0] points = vtk.vtkPoints() for j in range(count): points.InsertPoint(j, data[j, 0], data[j, 1], data[j, 2]) para_spline = vtk.vtkParametricSpline() para_spline.SetPoints(points) para_spline.ClosedOn() # The number of output points set to 10 times of input points numberOfOutputPoints = count * 10 self.cells.InsertNextCell(numberOfOutputPoints) for k in range(0, numberOfOutputPoints): t = k * 1.0 / numberOfOutputPoints pt = [0.0, 0.0, 0.0] para_spline.Evaluate([t, t, t], pt, [0] * 9) if pt[0] != pt[0]: print pt continue self.points.InsertPoint(l, pt[0], pt[1], pt[2]) self.cells.InsertCellPoint(l) l += 1 self.contours[cnt].SetPoints(self.points) self.contours[cnt].SetPolys(self.cells) self.delaunay3D[cnt].SetInput(self.contours[cnt]) self.delaunay3D[cnt].SetAlpha(2) self.delaunayMapper[cnt].SetInput(self.delaunay3D[cnt].GetOutput()) self.surface_actor[cnt].SetMapper(self.delaunayMapper[cnt]) self.surface_actor[cnt].GetProperty().SetDiffuseColor(color[cnt][0], color[cnt][1], color[cnt][2]) self.surface_actor[cnt].GetProperty().SetSpecularColor(1, 1, 1) self.surface_actor[cnt].GetProperty().SetSpecular(0.4) self.surface_actor[cnt].GetProperty().SetSpecularPower(50) self.renderer.AddViewProp(self.surface_actor[cnt]) self.renderer.ResetCamera() point = self.renderer.GetActiveCamera().GetFocalPoint() dis = self.renderer.GetActiveCamera().GetDistance() self.renderer.GetActiveCamera().SetViewUp(0, 0, 1) self.renderer.GetActiveCamera().SetPosition(point[0], point[1] - dis, point[2]) self.renderer.ResetCameraClippingRange() self.render_window.Render() # Manually set to trackball style self.window_interactor.SetKeyCode('t') self.window_interactor.CharEvent() self.window_interactor.GetInteractorStyle().AddObserver("KeyPressEvent", self.KeyPressCallback) self.window_interactor.GetInteractorStyle().AddObserver("CharEvent", self.KeyPressCallback)
def SPIRIT(A, lamb, energy, k0=1, holdOffTime=0, reorthog=False, evalMetrics="F"): A = np.mat(A) n = A.shape[1] totalTime = A.shape[0] Proj = npm.ones((totalTime, n)) * np.nan recon = npm.zeros((totalTime, n)) # initialize w_i to unit vectors W = npm.eye(n) d = 0.01 * npm.ones((n, 1)) m = k0 # number of eigencomponents relErrors = npm.zeros((totalTime, 1)) sumYSq = 0.0 E_t = [] sumXSq = 0.0 E_dash_t = [] res = {} k_hist = [] W_hist = [] anomalies = [] # incremental update W lastChangeAt = 0 for t in range(totalTime): k_hist.append(m) # update W for each y_t x = A[t, :].T # new data as column vector for j in range(m): W[:, j], d[j], x = updateW(x, W[:, j], d[j], lamb) Wj = W[:, j] # Grams smit reorthog if reorthog == True: W[:, :m], R = npm.linalg.qr(W[:, :m]) # compute low-D projection, reconstruction and relative error Y = W[:, :m].T * A[t, :].T # project to m-dimensional space xActual = A[t, :].T # actual vector of the current time xProj = W[:, :m] * Y # reconstruction of the current time Proj[t, :m] = Y.T recon[t, :] = xProj.T xOrth = xActual - xProj relErrors[t] = npm.sum(npm.power(xOrth, 2)) / npm.sum(npm.power(xActual, 2)) # update energy sumYSq = lamb * sumYSq + npm.sum(npm.power(Y, 2)) E_dash_t.append(sumYSq) sumXSq = lamb * sumXSq + npm.sum(npm.power(A[t, :], 2)) E_t.append(sumXSq) # Record RSRE if t == 0: top = 0.0 bot = 0.0 top = top + npm.power(npm.linalg.norm(xActual - xProj), 2) bot = bot + npm.power(npm.linalg.norm(xActual), 2) new_RSRE = top / bot if t == 0: RSRE = new_RSRE else: RSRE = npm.vstack((RSRE, new_RSRE)) ### Metric EVALUATION ### # deviation from truth if evalMetrics == "T": Qt = W[:, :m] if t == 0: res["subspace_error"] = npm.zeros((totalTime, 1)) res["orthog_error"] = npm.zeros((totalTime, 1)) res["angle_error"] = npm.zeros((totalTime, 1)) Cov_mat = npm.zeros([n, n]) # Calculate Covarentce Matrix of data up to time t Cov_mat = lamb * Cov_mat + npm.dot(xActual, xActual.T) # Get eigenvalues and eigenvectors WW, V = npm.linalg.eig(Cov_mat) # Use this to sort eigenVectors in according to deccending eigenvalue eig_idx = WW.argsort() # Get sort index eig_idx = eig_idx[::-1] # Reverse order (default is accending) # v_r = highest r eigen vectors (accoring to thier eigenvalue if sorted). V_k = V[:, eig_idx[:m]] # Calculate subspace error C = npm.dot(V_k, V_k.T) - npm.dot(Qt, Qt.T) res["subspace_error"][t, 0] = 10 * np.log10(npm.trace(npm.dot(C.T, C))) # frobenius norm in dB # Calculate angle between projection matrixes D = npm.dot(npm.dot(npm.dot(V_k.T, Qt), Qt.T), V_k) eigVal, eigVec = npm.linalg.eig(D) angle = npm.arccos(np.sqrt(max(eigVal))) res["angle_error"][t, 0] = angle # Calculate deviation from orthonormality F = npm.dot(Qt.T, Qt) - npm.eye(m) res["orthog_error"][t, 0] = 10 * np.log10(npm.trace(npm.dot(F.T, F))) # frobenius norm in dB # Energy thresholding ###################### # check the lower bound of energy level if sumYSq < energy[0] * sumXSq and lastChangeAt < t - holdOffTime and m < n: lastChangeAt = t m = m + 1 anomalies.append(t) # print 'Increasing m to %d at time %d (ratio %6.2f)\n' % (m, t, 100 * sumYSq/sumXSq) # check the upper bound of energy level elif sumYSq > energy[1] * sumXSq and lastChangeAt < t - holdOffTime and m < n and m > 1: lastChangeAt = t m = m - 1 # print 'Decreasing m to %d at time %d (ratio %6.2f)\n' % (m, t, 100 * sumYSq/sumXSq) W_hist.append(W[:, :m]) # set outputs # Grams smit reorthog if reorthog == True: W[:, :m], R = npm.linalg.qr(W[:, :m]) # Data Stores res2 = { "hidden": Proj, # Array for hidden Variables "E_t": np.array(E_t), # total energy of data "E_dash_t": np.array(E_dash_t), # hidden var energy "e_ratio": np.array(E_dash_t) / np.array(E_t), # Energy ratio "rel_orth_err": relErrors, # orthoX error "RSRE": RSRE, # Relative squared Reconstruction error "recon": recon, # reconstructed data "r_hist": k_hist, # history of r values "W_hist": W_hist, # history of Weights "anomalies": anomalies, } res.update(res2) return res
def GeneralFluidSolve (Q, R, Q0=[], prec=1e-14): """ Returns the parameters of the matrix-exponentially distributed stationary distribution of a general Markovian fluid model, where the fluid rates associated with the states of the background process can be arbitrary (zero is allowed as well). Using the returned 4 parameters the stationary solution can be obtained as follows. The probability that the fluid level is zero while being in different states of the background process is given by vector mass0. The density that the fluid level is x while being in different states of the background process is .. math:: \pi(x)=ini\cdot e^{K x}\cdot clo. Parameters ---------- Q : matrix, shape (N,N) The generator of the background Markov chain R : diagonal matrix, shape (N,N) The diagonal matrix of the fluid rates associated with the different states of the background process Q0 : matrix, shape (N,N), optional The generator of the background Markov chain at level 0. If not provided, or empty, then Q0=Q is assumed. The default value is empty. precision : double, optional Numerical precision for computing the fundamental matrix. The default value is 1e-14 Returns ------- mass0 : matrix, shape (1,Np+Nm) The stationary probability vector of zero level ini : matrix, shape (1,Np) The initial vector of the stationary density K : matrix, shape (Np,Np) The matrix parameter of the stationary density clo : matrix, shape (Np,Np+Nm) The closing matrix of the stationary density """ N = Q.shape[0] # partition the state space according to zero, positive and negative fluid rates ix = np.arange(N) ixz = ix[np.abs(np.diag(R))<=prec] ixp = ix[np.diag(R)>prec] ixn = ix[np.diag(R)<-prec] Nz = len(ixz) Np = len(ixp) Nn = len(ixn) # permutation matrix that converts between the original and the partitioned state ordering P = ml.zeros((N,N)) for i in range(Nz): P[i,ixz[i]]=1 for i in range(Np): P[Nz+i,ixp[i]]=1 for i in range(Nn): P[Nz+Np+i,ixn[i]]=1 iP = P.I Qv = P*Q*iP Rv = P*R*iP # new fluid process censored to states + and - iQv00 = la.pinv(-Qv[:Nz,:Nz]) Qbar = Qv[Nz:, Nz:] + Qv[Nz:,:Nz]*iQv00*Qv[:Nz,Nz:] absRi = Diag(np.abs(1./np.diag(Rv[Nz:,Nz:]))) Qz = absRi * Qbar Psi, K, U = FluidFundamentalMatrices (Qz[:Np,:Np], Qz[:Np,Np:], Qz[Np:,:Np], Qz[Np:,Np:], "PKU", prec) # closing matrix Pm = np.hstack((ml.eye(Np), Psi)) * absRi iCn = absRi[Np:,Np:] iCp = absRi[:Np,:Np] clo = np.hstack(((iCp*Qv[Nz:Nz+Np,:Nz]+Psi*iCn*Qv[Nz+Np:,:Nz])*iQv00, Pm)) if len(Q0)==0: # regular boundary behavior clo = clo * P # go back the the original state ordering # calculate boundary vector Ua = iCn*Qv[Nz+Np:,:Nz]*iQv00*ml.ones((Nz,1)) + iCn*ml.ones((Nn,1)) + Qz[Np:,:Np]*la.inv(-K)*clo*ml.ones((Nz+Np+Nn,1)) pm = Linsolve (ml.hstack((U,Ua)).T, ml.hstack((ml.zeros((1,Nn)),ml.ones((1,1)))).T).T # create the result mass0 = ml.hstack((pm*iCn*Qv[Nz+Np:,:Nz]*iQv00, ml.zeros((1,Np)), pm*iCn))*P ini = pm*Qz[Np:,:Np] else: # solve a linear system for ini(+), pm(-) and pm(0) Q0v = P*Q0*iP M = ml.vstack((-clo*Rv, Q0v[Nz+Np:,:], Q0v[:Nz,:])) Ma = ml.vstack((np.sum(la.inv(-K)*clo,1), ml.ones((Nz+Nn,1)))) sol = Linsolve (ml.hstack((M,Ma)).T, ml.hstack((ml.zeros((1,N)),ml.ones((1,1)))).T).T; ini = sol[:,:Np] clo = clo * P mass0 = ml.hstack((sol[:,Np+Nn:], ml.zeros((1,Np)), sol[:,Np:Np+Nn]))*P return mass0, ini, K, clo
def FRHH32(streams, rr, alpha, sci = 0): """ Fast row-Householder Subspace Traking Algorithm, Non adaptive version """ #=============================================================================== # #Initialise variables and data structures #=============================================================================== # check input is type float32 streams = float32(streams) alpha = float32(alpha) N = streams.shape[1] # No. of streams # Data Stores E_t = [float32(0)] # time series of total energy E_dash_t = [float32(0)] # time series of reconstructed energy z_dash = npm.zeros((1,N), dtype = float32) # time series of reconstructed data RSRE = mat([float32(0)]) # time series of Root squared Reconstruction Error hid_var = npm.zeros((streams.shape[0], N), dtype = float32) # Array of hidden Variables seed(111) # Initial Q(0) - either random or I # Random qq,RR = qr(rand(N,rr)) # generate random orthonormal matrix N x r Q_t = [mat(float32(qq))] # Initialise Q_t - N x r # Identity # q_I = npm.eye(N, rr) # Q_t = [q_I] S_t = [npm.ones((rr,rr), dtype = float32) * float32(0.00001)] # Initialise S_t - r x r No_inp_count = 0 # count of number of times there was no input i.e. z_t = [0,...,0] No_inp_marker = zeros((1,streams.shape[0] + 1)) v_vec_min_1 = npm.zeros((rr,1), dtype = float32) iter_streams = iter(streams) for t in range(1, streams.shape[0] + 1): z_vec = mat(iter_streams.next()) z_vec = z_vec.T # Now a column Vector hh = Q_t[t-1].T * z_vec # 13a Z = z_vec.T * z_vec - hh.T * hh # 13b # Z = float(Z) # cheak that Z is really scalar if Z > 0.00000000001 : # Refined version, sci accounts better for tracked eigen values if sci != 0: u_vec = S_t[t-1] * v_vec_min_1 extra_term = 2 * alpha * sci * u_vec * v_vec_min_1.T extra_term = float32(extra_term) else: extra_term = float32(0) X = alpha * S_t[t-1] + hh * hh.T - extra_term # QR method - hopefully more stable aa = X.T b = sqrt(Z[0,0]) * hh # b_vec = solve(aa,b) b_vec = QRsolveM(aa,b) b_vec =float32(b_vec) beta = float32(4) * (b_vec.T * b_vec + 1) phi_sq_t = float32(0.5) + (float32(1.0) / sqrt(beta)) phi_t = sqrt(phi_sq_t) gamma = (float32(1) - float32(2) * phi_sq_t) / (float32(2) * phi_t) delta = phi_t / sqrt(Z) v_vec_t = multiply(gamma , b_vec) S_t.append(X - multiply(float32(1) /delta , v_vec_t * hh.T)) w_vec = multiply(delta , hh) - v_vec_t e_vec = multiply(delta, z_vec) - (Q_t[t-1] * w_vec) Q_t.append(Q_t[t-1] - float32(2) * (e_vec * v_vec_t.T)) v_vec_min_1 = v_vec_t # update for next time step # Record hidden variables hid_var[t-1,:hh.shape[0]] = hh.T # Record reconstrunted z new_z_dash = Q_t[t-1] * hh z_dash = npm.vstack((z_dash, new_z_dash.T)) # Record RSRE new_RSRE = RSRE[0,-1] + (((norm(new_z_dash - z_vec)) ** 2) / (norm(z_vec) ** 2)) RSRE = npm.vstack((RSRE, mat(new_RSRE))) else: # Record hidden variables hid_var[t-1,:hh.shape[0]] = hh.T # Record reconstrunted z new_z_dash = Q_t[t-1] * hh z_dash = npm.vstack((z_dash, new_z_dash.T)) # Record RSRE new_RSRE = RSRE[0,-1] + (((norm(new_z_dash - z_vec)) ** 2) / (norm(z_vec) ** 2)) RSRE = npm.vstack((RSRE, mat(new_RSRE))) # Repeat last entries Q_t.append(Q_t[-1]) S_t.append(S_t[-1]) # increment count No_inp_count += 1 No_inp_marker[t-1] = 1 # convert to tuples to save memory Q_t = tuple(Q_t) S_t = tuple(S_t) rr = array(rr) E_t = array(E_t) E_dash_t = array(E_dash_t) return Q_t, S_t, rr, E_t, E_dash_t, hid_var, z_dash, RSRE, No_inp_count, No_inp_marker