def mpow2(A, n): """ Returns the n-th power of A. Here, this is computed using eigenvalue decomposition. ========== Parameter: ========== A : *array* the square matrix from which the n-th power should be returned n : *integer* the power ======== Returns: ======== B : *array* B = A^n """ D, L = eig(A) if isreal(A).all(): return reduce(dot, [L, diag(D**n), inv(L)]).real else: return reduce(dot, [L, diag(D**n), inv(L)])
def fib2ABD(fiber_layup): ''' :param fiber_layup: type(fiber_layup)=dict, Mandatory: numbers from 1 to n_layer where n_layer is the number of layers. n_layer :subparam fiber_layup[i_layer]: type(fiber_layup[i_layer])=dict, Mandatory fields: E1, E2, nu12, G12, angle, thickness, z_start, z_end. Optional fields: fiber_type, :return fiber_layup["ABD"] = ABD: ["thickness"] = sum(fiber_layup[i_layer]["thickness"]) :subfield fiber_layup[i_layer]: ["S_l"] = S_l, ["Q_l"] = Q_l, ["Q_G"] = Q_G, ["A"] = A, ["B"] = B, ["D"] = D ''' A = py.zeros((3, 3)) B = py.zeros((3, 3)) D = py.zeros((3, 3)) for i_fib in range(1, fiber_layup["fiber_nr"] + 1): # Setting up local compliance matrix (S) for each fiber fiber_layup[i_fib]["S_l"] = get_compliance_matrix(fiber_layup[i_fib]) # Getting local stiffness matrix (Q) - (Q = inv(S)) fiber_layup[i_fib]["Q_l"] = py.inv(fiber_layup[i_fib]["S_l"]) # Make transformation matrix for each fiber (T_lg, local->global - inv(T_lg)=T_gl, Global->local) fiber_layup[i_fib]["T_L2G"] = get_transform_Local2Global( fiber_layup[i_fib]["angle"]) fiber_layup[i_fib]["T_G2L"] = py.inv(fiber_layup[i_fib]["T_L2G"]) # Make global stiffness matrix fiber_layup[i_fib]["Q_G"] = py.dot( fiber_layup[i_fib]["T_L2G"], py.dot(fiber_layup[i_fib]["Q_l"], fiber_layup[i_fib]["T_L2G"].T)) # Make global A, B, D A += fiber_layup[i_fib]["Q_G"] * (fiber_layup[i_fib]["z_end"] - fiber_layup[i_fib]["z_start"]) B += fiber_layup[i_fib]["Q_G"] * 1.0 / 2.0 * ( fiber_layup[i_fib]["z_end"]**2 - fiber_layup[i_fib]["z_start"]**2) D += fiber_layup[i_fib]["Q_G"] * 1.0 / 3.0 * ( fiber_layup[i_fib]["z_end"]**3 - fiber_layup[i_fib]["z_start"]**3) # Collect ABD matrix fiber_layup["A"] = A fiber_layup["B"] = B fiber_layup["D"] = D ABD = py.zeros((6, 6)) ABD[:3, :3] = A ABD[:3, 3:] = B ABD[3:, :3] = B ABD[3:, 3:] = D fiber_layup["ABD"] = ABD fiber_layup["abd"] = py.inv(fiber_layup["ABD"]) fiber_layup["E_x"] = 1.0 / (fiber_layup["abd"][0, 0] * fiber_layup["thickness"]) fiber_layup["E_y"] = 1.0 / (fiber_layup["abd"][1, 1] * fiber_layup["thickness"]) fiber_layup["G_xy"] = 1.0 / (fiber_layup["abd"][2, 2] * fiber_layup["thickness"]) return (fiber_layup)
def stackElements(S1, S2): # Reursive relations, eq (59-62) in "A combined three-dimensional finite element and scattering matrix # method for the analysis of plane wave diffraction by bi-periodic, multilayered structures" # (Dossou 2012a) RIn1, TIn1, TOut1, ROut1 = StoRT(S1) RIn2, TIn2, TOut2, ROut2 = StoRT(S2) I = pl.identity(RIn1.shape[0]) RIn = RIn1 + TOut1 * RIn2 * pl.inv(I - ROut1 * RIn2) * TIn1 TIn = TIn2 * pl.inv(I - ROut1 * RIn2) * TIn1 ROut = ROut2 + TIn2 * ROut1 * pl.inv(I - RIn2 * ROut1) * TOut2 TOut = TOut1 * pl.inv(I - RIn2 * ROut1) * TOut2 return RTtoS(RIn, TIn, TOut, ROut)
def kalman(F,G,H,u,y,x0,Px0,Px,Py): """ computes the discrete-time Kalman-Filter parameters: F - system matrix [m x m] G - input matrix x(k+1) = F*x(k) + G*u(k) [m x d_u] H - observation matrix y(k) = H*x(k) u: input vector [d_u x n] y: observations [d_y x n] x0: initial estimate [d_x,] Px: (initial) covariance matrix of x Py: covariance matrix of y Q: covariance of dynamical noise (can be 0) returns: (state, state_cov) the state and the state covariance matrices Implementation according to Geering: Regelungstechnik, Springer (2004), p. 259f. """ n = y.shape[-1] if y.shape[-1] != u.shape[-1]: raise ValueError, 'y and u do not have same length!' # reserve space for results Px_minus = zeros((Px0.shape[0],Px0.shape[1],n)) Px_plus = zeros((Px0.shape[0],Px0.shape[1],n)) x_minus = zeros((x0.shape[0],n)) x_plus = zeros((x0.shape[0],n)) Px_minus[:,:,0] = Px0 x_minus[:,0:1] = x0 # compute for each time frame for k in xrange(n): Px_plus[:,:,k] = Px_minus[:,:,k] - reduce(dot, [Px_minus[:,:,k], H.T, inv(Py + dot(H,dot(Px_minus[:,:,k],H.T))), H, Px_minus[:,:,k]]) L = dot(Px_minus[:,:,k], dot(H.T, inv( Py + dot(H, dot(Px_minus[:,:,k],H.T)) ))) x_plus[:,k:k+1] = x_minus[:,k:k+1] + dot(L, (y[:,k:k+1] - dot(H,x_minus[:,k:k+1]) )) if k < n-1: #print 'k = ', k, 'x-plus: ',x_plus.shape,'u',u.shape, 'x_minus:', x_minus.shape Px_minus[:,:,k+1] = (dot(F, dot(Px_plus[:,:,k],F.T)) + dot(G, dot(Px,G.T))) x_minus[:,k+1:k+2] = dot(F,x_plus[:,k:k+1]) + dot(G,u[:,k:k+1]) return x_plus, Px_plus
def kalman(F, G, H, u, y, x0, Px0, Px, Py): """ computes the discrete-time Kalman-Filter parameters: F - system matrix [m x m] G - input matrix x(k+1) = F*x(k) + G*u(k) [m x d_u] H - observation matrix y(k) = H*x(k) u: input vector [d_u x n] y: observations [d_y x n] x0: initial estimate [d_x,] Px: (initial) covariance matrix of x Py: covariance matrix of y Q: covariance of dynamical noise (can be 0) returns: (state, state_cov) the state and the state covariance matrices Implementation according to Geering: Regelungstechnik, Springer (2004), p. 259f. """ n = y.shape[-1] if y.shape[-1] != u.shape[-1]: raise ValueError, 'y and u do not have same length!' # reserve space for results Px_minus = zeros((Px0.shape[0], Px0.shape[1], n)) Px_plus = zeros((Px0.shape[0], Px0.shape[1], n)) x_minus = zeros((x0.shape[0], n)) x_plus = zeros((x0.shape[0], n)) Px_minus[:, :, 0] = Px0 x_minus[:, 0:1] = x0 # compute for each time frame for k in xrange(n): Px_plus[:, :, k] = Px_minus[:, :, k] - reduce(dot, [ Px_minus[:, :, k], H.T, inv(Py + dot(H, dot(Px_minus[:, :, k], H.T))), H, Px_minus[:, :, k] ]) L = dot(Px_minus[:, :, k], dot(H.T, inv(Py + dot(H, dot(Px_minus[:, :, k], H.T))))) x_plus[:, k:k + 1] = x_minus[:, k:k + 1] + dot( L, (y[:, k:k + 1] - dot(H, x_minus[:, k:k + 1]))) if k < n - 1: #print 'k = ', k, 'x-plus: ',x_plus.shape,'u',u.shape, 'x_minus:', x_minus.shape Px_minus[:, :, k + 1] = (dot(F, dot(Px_plus[:, :, k], F.T)) + dot(G, dot(Px, G.T))) x_minus[:, k + 1:k + 2] = dot(F, x_plus[:, k:k + 1]) + dot(G, u[:, k:k + 1]) return x_plus, Px_plus
def estimate_kernel(self, X, P, M): """estimate the ide model's kernel weights from data stored in the ide object""" # form Xi variables Xi_0 = pb.zeros([self.model.nx, self.model.nx]) Xi_1 = pb.zeros([self.model.nx, self.model.nx]) for t in range(1, len(X)): Xi_0 += pb.dot(X[t - 1, :].reshape(self.model.nx, 1), X[t, :].reshape(self.model.nx, 1).T) + M[ t, : ].reshape(self.model.nx, self.model.nx) Xi_1 += pb.dot(X[t - 1, :].reshape(self.model.nx, 1), X[t - 1, :].reshape(self.model.nx, 1).T) + P[ t - 1, : ].reshape(self.model.nx, self.model.nx) # form Upsilon and upsilons Upsilon = pb.zeros([self.model.ntheta, self.model.ntheta]) upsilon0 = pb.zeros([1, self.model.ntheta]) upsilon1 = pb.zeros([1, self.model.ntheta]) for i in range(self.model.nx): for j in range(self.model.nx): Upsilon += Xi_1[i, j] * self.model.Delta_Upsilon[j, i] upsilon0 += Xi_0[i, j] * self.model.Delta_upsilon[j, i] upsilon1 += Xi_1[i, j] * self.model.Delta_upsilon[j, i] upsilon1 = upsilon1 * self.model.xi Upsilon = Upsilon * self.model.Ts * self.model.varsigma weights = pb.dot(pb.inv(Upsilon.T), upsilon0.T - upsilon1.T) return weights
def __init__(self, x_wc, K): self.x_wc = x_wc self.x_cw = coord_xfms.ssc.inverse(self.x_wc) # camera calibration matrix self.K = K # camera center self.C = self.x_wc[0:3] # transforms points in world frame to points in camera frame self.wHc = coord_xfms.xyzrph2matrix(self.x_cw) # transforms points in camera frame to points in world frame self.cHw = coord_xfms.xyzrph2matrix(self.x_wc) # the stupid [R t] notation that I absolutely hate self.Rt = self.wHc[0:3, :] # projects points in world frame to image plane of camera self.P = K.dot(self.Rt) # used for normalized image points self.invK = pl.inv(K[0:3, 0:3]) # used in back-projecting points to rays self.pinvP = pl.pinv(self.P)
def __init__ (self, x_wc, K): self.x_wc = x_wc self.x_cw = coord_xfms.ssc.inverse (self.x_wc) # camera calibration matrix self.K = K # camera center self.C = self.x_wc[0:3] # transforms points in world frame to points in camera frame self.wHc = coord_xfms.xyzrph2matrix (self.x_cw) # transforms points in camera frame to points in world frame self.cHw = coord_xfms.xyzrph2matrix (self.x_wc) # the stupid [R t] notation that I absolutely hate self.Rt = self.wHc[0:3,:] # projects points in world frame to image plane of camera self.P = K.dot (self.Rt) # used for normalized image points self.invK = pl.inv (K[0:3,0:3]) # used in back-projecting points to rays self.pinvP = pl.pinv (self.P)
def affineTransform(image, x1, y1, x2, y2, x3, y3, M, N): # Construct the matrix M mat_M = array([[x1, y1, 1, 0, 0, 0], \ [0, 0, 0, x1, y1, 1], \ [x2, y2, 1, 0, 0, 0], \ [0, 0, 0, x2, y2, 1], \ [x3, y3, 1, 0, 0, 0], \ [0, 0, 0, x3, y3, 1]]) # Construct vector q q = array([[0], [0], [M], [0], [M], [N]]) p = lstsq(mat_M, q) a, b, c, d, e, f = p[0][0][0], \ p[0][1][0], \ p[0][2][0], \ p[0][3][0], \ p[0][4][0], \ p[0][5][0] # A is the resulting matrix that describes the transformation A = array([[a, b, c], \ [d, e, f], \ [0, 0, 1]]) # Create the new image b = array([zeros(N, float)] * M) for i in range(0, M): for j in range(0, N): old_coor = dot(inv(A),([[i],[j],[1]])) b[i][j] = pV(image, old_coor[0][0], old_coor[1][0], 'linear') return b
def _filter(self,Y): ## initialise xf=self.x0 Pf=self.P0 # filter quantities xfStore =[] PfStore=[] #calculate the weights Wm_i,Wc_i=self.sigma_vectors_weights() for y in Y: #calculate the sigma points matrix, each column is a sigma vector Xi_f_=self.sigma_vectors(xf,Pf) #propogate sigma verctors through non-linearity Xi_f=self.state_equation(Xi_f_) #pointwise multiply by weights and sum along y-axis xf_=pb.sum(Wm_i*Xi_f,1) xf_=xf_.reshape(self.nx,1) #purturbation Xi_purturbation=Xi_f-xf_ weighted_Xi_purturbation=Wc_i*Xi_purturbation Pf_=pb.dot(Xi_purturbation,weighted_Xi_purturbation.T)+self.Sigma_e #measurement update equation Pyy=dots(self.C,Pf_,self.C.T)+self.Sigma_varepsilon Pxy=pb.dot(Pf_,self.C.T) K=pb.dot(Pxy,pb.inv(Pyy)) yf_=pb.dot(self.C,xf_) xf=xf_+pb.dot(K,(y-yf_)) Pf=pb.dot((pb.eye(self.nx)-pb.dot(K,self.C)),Pf_) xfStore.append(xf) PfStore.append(Pf) return xfStore,PfStore
def get_projection_transformed_point(src_x_values, src_y_values, dest_width, dest_height, target_point_x, target_point_y): sx1, sy1 = src_x_values[0], src_y_values[0] # tl sx2, sy2 = src_x_values[1], src_y_values[1] # bl sx3, sy3 = src_x_values[2], src_y_values[2] # br sx4, sy4 = src_x_values[3], src_y_values[3] # tr source_points_123 = pl.matrix([[sx1, sx2, sx3], [sy1, sy2, sy3], [1, 1, 1]]) source_point_4 = [[sx4], [sy4], [1]] scale_to_source = pl.solve(source_points_123, source_point_4) l, m, t = [float(x) for x in scale_to_source] unit_to_source = pl.matrix([[l * sx1, m * sx2, t * sx3], [l * sy1, m * sy2, t * sy3], [l, m, t]]) dx1, dy1 = 0, 0 dx2, dy2 = 0, dest_height dx3, dy3 = dest_width, dest_height dx4, dy4 = dest_width, 0 dest_points_123 = pl.matrix([[dx1, dx2, dx3], [dy1, dy2, dy3], [1, 1, 1]]) dest_point_4 = pl.matrix([[dx4], [dy4], [1]]) scale_to_dest = pl.solve(dest_points_123, dest_point_4) l, m, t = [float(x) for x in scale_to_dest] unit_to_dest = pl.matrix([[l * dx1, m * dx2, t * dx3], [l * dy1, m * dy2, t * dy3], [l, m, t]]) source_to_unit = pl.inv(unit_to_source) source_to_dest = unit_to_dest @ source_to_unit x, y, z = [float(w) for w in (source_to_dest @ pl.matrix([ [target_point_x], [target_point_y], [1]]))] x /= z y /= z y = target_point_y * 2 - y return x, y
def get_transformation_matrix(matrix): # Get the vector p and the values that are in there by taking the SVD. # Since D is diagonal with the eigenvalues sorted from large to small # on the diagonal, the optimal q in min ||Dq|| is q = [[0]..[1]]. # Therefore, p = Vq means p is the last column in V. U, D, V = svd(matrix) p = V[8][:] return inv(array([[p[0],p[1],p[2]], [p[3],p[4],p[5]], [p[6],p[7],p[8]]]))
def JointValuesFromTransform(robot, Tdesired): """ Find the dummy joint values such that the Transform of the baselink is Tdesired. T0 is the initial Transform of the baselink. """ R = dot(inv(robot.baselinkinittransform[0:3, 0:3]), Tdesired[0:3, 0:3]) [h1, h2, h3] = AnglesFromRot(R) offset = dot(R, robot.baselinkinittransform[0:3, 3]) [s1, s2, s3] = Tdesired[0:3, 3] - offset return [s1, s2, s3, h1, h2, h3]
def MLEf(x,x_data,y_data): X = x_data.numpy() Y = y_data.numpy() X = np.array([np.concatenate((np.array([1]),X[i,:])) for i in range(X.shape[0])]) B = pl.inv(X.T@X)@X.T@Y s = 0 N = X.shape[1] for i in np.arange(N): s = s + B[i]*(x**(i)) return s,B.reshape(1,-1)
def setup_asr_step_methods(m, vars, additional_stochs=[]): # groups RE stochastics that are suspected of being dependent groups = [] fe_group = [n for n in vars.get('beta', []) if isinstance(n, mc.Stochastic)] ap_group = [n for n in vars.get('gamma', []) if isinstance(n, mc.Stochastic)] groups += [[g_i, g_j] for g_i, g_j in zip(ap_group[1:], ap_group[:-1])] + [fe_group, ap_group, fe_group+ap_group] for a in vars.get('hierarchy', []): group = [] col_map = dict([[key, i] for i,key in enumerate(vars['U'].columns)]) if a in vars['U']: for b in nx.shortest_path(vars['hierarchy'], 'all', a): if b in vars['U']: n = vars['alpha'][col_map[b]] if isinstance(n, mc.Stochastic): group.append(n) groups.append(group) #if len(group) > 0: #group += ap_group #groups.append(group) #group += fe_group #groups.append(group) for stoch in groups: if len(stoch) > 0 and pl.all([isinstance(n, mc.Stochastic) for n in stoch]): # only step certain stochastics, for understanding convergence #if 'gamma_i' not in stoch[0].__name__: # print 'no stepper for', stoch # m.use_step_method(mc.NoStepper, stoch) # continue #print 'finding Normal Approx for', [n.__name__ for n in stoch] if additional_stochs == []: vars_to_fit = [vars.get('p_obs'), vars.get('pi_sim'), vars.get('smooth_gamma'), vars.get('parent_similarity'), vars.get('mu_sim'), vars.get('mu_age_derivative_potential'), vars.get('covariate_constraint')] else: vars_to_fit = additional_stochs try: raise ValueError na = mc.NormApprox(vars_to_fit + stoch) na.fit(method='fmin_powell', verbose=0) cov = pl.array(pl.inv(-na.hess), order='F') #print 'opt:', pl.round_([n.value for n in stoch], 2) #print 'cov:\n', cov.round(4) if pl.all(pl.eigvals(cov) >= 0): m.use_step_method(mc.AdaptiveMetropolis, stoch, cov=cov) else: raise ValueError except ValueError: #print 'cov matrix is not positive semi-definite' m.use_step_method(mc.AdaptiveMetropolis, stoch)
def train_readout(states, targets, reg_fact=0): # train readout with linear regression # states... numpy array with states[i,j] the state of neuron j in example i # targets.. the targets for training/testing. targets[i] is target of example i # reg_fact..regularization factor. If set to 0, no regularization is performed # returns: # w...weight vector if reg_fact == 0: w = np.linalg.lstsq(states, targets)[0] else: w = np.dot(np.dot(pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) + np.dot(states.T, states)), states.T), targets) return w
def EM(self,Y,U,eps = 0.000000001): converged = False l = [1000] while not converged: # E step X, P, K, M = self.rtssmooth(Y, U) Xi11 = pb.sum([Pt + x*x.T for Pt,x in zip(P,X)],0) Xi10 = pb.sum([Mt + x1*x.T for Mt,x1,x in zip(M[1:],X[:-1],X[1:])],0) # M step self.A = pb.inv(Xi11)*Xi10 l.append(self.likelihood(self.x0,X,Y,U)) converged = abs(l[-1] - l[-2]) < eps print l[-1] return l, X, P
def check_actuated_torques(hrp, q, qd, qdd, tau, J, F_ext): """Check actuated torques `tau` computed against the external wrench F_ext using Equation (8) from (Mistry, Buchli and Schall, 2010). robot -- robot object q -- full-body configuration qd -- full-body velocity qdd -- full-body acceleration tau -- active joint torques J -- contact Jacobian F_ext -- contact wrench """ with hrp.rave: hrp.rave.SetDOFValues(q) hrp.rave.SetDOFVelocities(qd) _, tc, tg = hrp.rave.ComputeInverseDynamics(qdd, returncomponents=True) M = hrp.compute_inertia_matrix(hrp.q) S = hstack([eye(50), zeros((50, 6))]) SMS_inv = inv(dot(S, dot(inv(M), S.T))) S_bar = dot(SMS_inv, dot(S, inv(M))).T v = dot(S_bar.T, (tc + tg - dot(J.T, F_ext))) tau_check = dot(SMS_inv, qdd[:50]) + v return norm(tau - tau_check) < 1e-5
def compute_readout_weights(states, targets, reg_fact=0): """ Train readout with linear regression :param states: numpy array with states[i, j], the state of neuron j in example i :param targets: numpy array with targets[i], while target i corresponds to example i :param reg_fact: regularization factor; 0 results in no regularization :return: numpy array with weights[j] """ if reg_fact == 0: w = np.linalg.lstsq(states, targets)[0] else: w = np.dot( np.dot( pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) + np.dot(states.T, states)), states.T), targets) return w
def fit_ellipse(pts): (x,y)=pts cm=(x.mean(),y.mean()) D=np.transpose([x**2, x*y, y**2, x, y, np.ones(len(x))]) S=np.dot(np.transpose(D),D) C=np.zeros((6,6)) C[5,5]=0; C[0,2]=2; C[1,1]=-1; C[2,0]=2 (gevec, geval)=pl.eig( np.dot(pl.inv(S),C) ) (PosR, PosC)= np.where(geval>0 & ~np.isinf(geval)) a=gevec[:,PosC] (v,w)=pl.eig(np.array([[a[0],a[1]/2],[a[1]/2,a[2]]])) vect1=w[:,0] theta=np.arctan2(vect1[1],vect1[0]) return cm, v[1], v[0], theta
def normal_equation(x, y): """ Description: Computes the parameters based the training examples and values of the target variables using the closed form formula theta = (inverse(X.transpose()*X)*X.transpose())*Y where X.transpose() computes the transpose of matrix X and * implies matrix multiplication. Parameters: x - an array of feature vectors y - target variables corresponding to the feature vectors Returns: theta - an array of parameters corresponding to the feature vectors. """ z = inv(dot(x.transpose(), x)) theta = dot(dot(z, x.transpose()), y) return theta
def perspectiveTransform(image, x1, y1, x2, y2, x3, y3, x4, y4, M, N): # Construct the matrix M x1_a, y1_a = 0, 0 x2_a, y2_a = M, 0 x3_a, y3_a = M, N x4_a, y4_a = 0, N mat_M = array([[x1, y1, 1, 0, 0, 0, -x1_a * x1, -x1_a * y1, -x1_a], \ [0, 0, 0, x1, y1, 1, -y1_a * x1, -y1_a * y1, -y1_a], \ [x2, y2, 1, 0, 0, 0, -x2_a * x2, -x2_a * y2, -x2_a], \ [0, 0, 0, x2, y2, 1, -y2_a * x2, -y2_a * y2, -y2_a], \ [x3, y3, 1, 0, 0, 0, -x3_a * x3, -x3_a * y3, -x3_a], \ [0, 0, 0, x3, y3, 1, -y3_a * x3, -y3_a * y3, -y3_a], \ [x4, y4, 1, 0, 0, 0, -x4_a * x4, -x4_a * y4, -x4_a], \ [0, 0, 0, x4, y4, 1, -y4_a * x4, -y4_a * y4, -y4_a]]) # Get the vector p and the values that are in there by taking the SVD. # Since D is diagonal with the eigenvalues sorted from large to small on # the diagonal, the optimal q in min ||Dq|| is q = [[0]..[1]]. Therefore, # p = Vq means p is the last column in V. U, D, V = svd(mat_M) p = V[8][:] a, b, c, d, e, f, g, h, i = p[0], \ p[1], \ p[2], \ p[3], \ p[4], \ p[5], \ p[6], \ p[7], \ p[8] # P is the resulting matrix that describes the transformation P = array([[a, b, c], \ [d, e, f], \ [g, h, i]]) # Create the new image b = array([zeros(M, float)] * N) for i in range(0, M): for j in range(0, N): or_coor = dot(inv(P),([[i],[j],[1]])) or_coor_h = or_coor[1][0] / or_coor[2][0], \ or_coor[0][0] / or_coor[2][0] b[j][i] = pV(image, or_coor_h[0], or_coor_h[1], 'linear') return b
def Kupdate(A,C,P_,Sigma_epsilon,x_,y): if (np.rank(A)!=2 or type(self.A)!=np.ndarray):raise TypeError('A should be rank two array') if (np.rank(C)!=2 or type(self.C)!=np.ndarray):raise TypeError('C should be rank two array') if (np.rank(Sigma_epsilon)!=2 or type(self.Sigma_epsilon)!=np.ndarray):raise TypeError('Sigma_epsilon should be rank two array') if (np.rank(P_)!=2 or type(P_)!=np.ndarray):raise TypeError('P should be rank two array') if type(x_)!=np.ndarray:raise TypeError('x0 should be rank two array') if type(y)!=np.ndarray:raise TypeError('y should be rank two array') # calculte Kalman gain K =pb.dot(pb.dot(P_,C.T),pb.inv(dots(C,P_,C.T) + Sigma_epsilon)) # update estimate with model output measurement x = x_ + pb.dot(K,(y-pb.dot(C,x_))) # update the state error covariance P = pb.dot((np.eye(self.nx)-pb.dot(K,C)),P_); return x,P
def estimate_kernel(self,X): """ estimate the ide parameters using least squares method Arguments ---------- X: list of ndarray state vectors Returns --------- least squares estimation of the IDE parameters """ Q=self.Q_calc(X) Z=pb.vstack(X[1:]) X_t_1=pb.vstack(X[:-1]) Q_t_1=pb.vstack(Q[:-1]) X_ls=pb.hstack((Q_t_1,X_t_1)) theta=dots(pb.inv(pb.dot(X_ls.T,X_ls)),X_ls.T,Z) parameters=[float(theta[i]) for i in range(theta.shape[0])] return parameters
def findMatrix( uN, dim, nCoeff, ptns, pascale, serendipity ): fop = g.PolynomialModelling( dim, nCoeff, pnts ) fop.setPascalsStyle( pascale ) fop.setSerendipityStyle( serendipity ) tmp = g.RPolynomialFunction( g.RVector( fop.polynomialFunction().size() ) ) tmp.fill( fop.startModel() ) print "base:", tmp G = P.zeros( ( len( pnts), len( tmp.elements() ) ) ) for i, p in enumerate( pnts ): for j, e in enumerate( tmp.elements() ): G[i,j] = e( p ) GI = P.inv( G ) coef = P.dot( GI, uN ) print coef print P.dot( G, coef ) tmp.fill( g.asvector( coef ) ) print coef, tmp return tmp
def compute_readout_weights(states, targets, reg_fact=0): """ Train readout with linear regression :param states: numpy array with states[i, j], the state of neuron j in example i :param targets: numpy array with targets[i], while target i corresponds to example i :param reg_fact: regularization factor; 0 results in no regularization :return: numpy array with weights[j] """ if reg_fact == 0: # lstsq solves the equation Xw = b for the best w w = np.linalg.lstsq(states, targets)[0] else: # pylab.inv -> inverse # pylab.eye -> identity matrix # Note that the inverse of kI_n = 1/k I_n for a scalar k. # This is somewhat related to the least squares equation. # A^TA x = A^T b # for vectors x and b w = np.dot(np.dot(pylab.inv(reg_fact * pylab.eye(np.size(states, 1)) + np.dot(states.T, states)), states.T), targets) return w
def findMatrix(uN, dim, nCoeff, ptns, pascale, serendipity): fop = g.PolynomialModelling(dim, nCoeff, pnts) fop.setPascalsStyle(pascale) fop.setSerendipityStyle(serendipity) tmp = g.RPolynomialFunction(g.RVector(fop.polynomialFunction().size())) tmp.fill(fop.startModel()) print("base:", tmp) G = P.zeros((len(pnts), len(tmp.elements()))) for i, p in enumerate(pnts): for j, e in enumerate(tmp.elements()): G[i, j] = e(p) GI = P.inv(G) coef = P.dot(GI, uN) print(coef) print(P.dot(G, coef)) tmp.fill(g.asvector(coef)) print(coef, tmp) return tmp
from __future__ import print_function, division, absolute_import import sys sys.path.insert(0, "../../") # from SBDet import parseToCoo, gen_sigs, mix, select_model from SBDet import * import pylab as P import numpy as np # tr = zload('./EstBiase-n_num.pk') tr = zload('./EstBiase-n_num-revised.pk') n_num, iso_n, PA_para, PA_lk, ER_para, ER_lk = zip(*tr['n_num']) x = iso_n y = np.array(PA_lk).reshape(-1) - np.array(ER_lk) P.plot(x, y, 'r.') # import ipdb;ipdb.set_trace() P.axis([0, max(x), 0, max(y)]) # solve least square problem n = len(x) # X = np.hstack([np.ones((n, 1)), np.array(x).reshape(-1, 1)]) X = np.array(x).reshape(-1, 1) beta = P.dot(P.dot(P.inv(P.dot(X.T, X)), X.T), np.array(y).reshape(-1, 1)) xp = np.linspace(0, max(x), 100) yp = xp * beta[0, 0] P.plot(xp, yp, 'b--') P.xlabel('Number of isolated nodes') P.ylabel('Difference between log liklihood of PA and ER') xm = max(x) * 0.5 P.text(xm, xm * beta - 500, 'y=%f x' % (beta)) P.show()
def setup_asr_step_methods(m, vars, additional_stochs=[]): # groups RE stochastics that are suspected of being dependent groups = [] fe_group = [ n for n in vars.get('beta', []) if isinstance(n, mc.Stochastic) ] ap_group = [ n for n in vars.get('gamma', []) if isinstance(n, mc.Stochastic) ] groups += [[g_i, g_j] for g_i, g_j in zip(ap_group[1:], ap_group[:-1]) ] + [fe_group, ap_group, fe_group + ap_group] for a in vars.get('hierarchy', []): group = [] col_map = dict([[key, i] for i, key in enumerate(vars['U'].columns)]) if a in vars['U']: for b in nx.shortest_path(vars['hierarchy'], 'all', a): if b in vars['U']: n = vars['alpha'][col_map[b]] if isinstance(n, mc.Stochastic): group.append(n) groups.append(group) #if len(group) > 0: #group += ap_group #groups.append(group) #group += fe_group #groups.append(group) for stoch in groups: if len(stoch) > 0 and pl.all( [isinstance(n, mc.Stochastic) for n in stoch]): # only step certain stochastics, for understanding convergence #if 'gamma_i' not in stoch[0].__name__: # print 'no stepper for', stoch # m.use_step_method(mc.NoStepper, stoch) # continue #print 'finding Normal Approx for', [n.__name__ for n in stoch] if additional_stochs == []: vars_to_fit = [ vars.get('p_obs'), vars.get('pi_sim'), vars.get('smooth_gamma'), vars.get('parent_similarity'), vars.get('mu_sim'), vars.get('mu_age_derivative_potential'), vars.get('covariate_constraint') ] else: vars_to_fit = additional_stochs try: raise ValueError na = mc.NormApprox(vars_to_fit + stoch) na.fit(method='fmin_powell', verbose=0) cov = pl.array(pl.inv(-na.hess), order='F') #print 'opt:', pl.round_([n.value for n in stoch], 2) #print 'cov:\n', cov.round(4) if pl.all(pl.eigvals(cov) >= 0): m.use_step_method(mc.AdaptiveMetropolis, stoch, cov=cov) else: raise ValueError except ValueError: #print 'cov matrix is not positive semi-definite' m.use_step_method(mc.AdaptiveMetropolis, stoch)
''' Created on Jun 5, 2016 @author: ahanagrawal ''' from GradientDescent import ConstructArrays import pylab import numpy as np if __name__ == '__main__': array = pylab.loadtxt("ex1/ex1data1.txt", dtype=float, delimiter=",") X, Y = ConstructArrays(array) X = np.matrix(X) Y = np.matrix(Y) print(pylab.inv(X.T * X) * X.T * Y)
def create_cm(dim,eigList1 = None, eigList2 = None): """ returns two real-valued commuting matrices of dimension dim x dim the eigenvalues of each matrix can be given; single complex numbers will be interpreted as pair of complex conjuates. With this restriction, the (internally augmented) lists must have the length of dim """ if eigList1 is None: eigList1 = rand(dim) if eigList2 is None: eigList2 = rand(dim) # order 1st array such that complex numbers are first EL1 = array(eigList1) imPos1 = find(iscomplex(EL1)) rePos1 = find(isreal(EL1)) # shorter than set comparisons :D EL1 = hstack([EL1[imPos1],EL1[rePos1]]) # order 2nd array such that complex numbers are last EL2 = array(eigList2) imPos2 = find(iscomplex(EL2)) rePos2 = find(isreal(EL2)) # shorter than set comparisons :D EL2 = hstack([EL2[rePos2],EL2[imPos2]]) # now: make eigenvalues of list #2, where a block is in list #1, # pairwise equal, and other way round EL2[1:2*len(imPos1):2] = EL2[0:2*len(imPos1):2] EL1[-2*len(imPos2)+1::2] = EL1[-2*len(imPos2)::2] if len(imPos2)*2 + len(imPos1)*2 > dim: raise ValueError( 'too many complex eigenvalues - cannot create commuting matrices') # augment lists ev1 = [] nev1 = 0 for elem in EL1: if elem.imag != 0.: ev1.append( array( [[elem.real, -elem.imag], [elem.imag, elem.real]])) nev1 += 2 else: ev1.append(elem) nev1 += 1 if nev1 != dim: raise ValueError( 'number of given eigenvalues #1 (complex: x2) does not match dim!') ev2 = [] nev2 = 0 for elem in EL2: if elem.imag != 0.: ev2.append( array( [[elem.real, -elem.imag], [elem.imag, elem.real]])) nev2 += 2 else: ev2.append(elem) nev2 += 1 if nev2 != dim: raise ValueError( 'number of given eigenvalues #2 (complex: x2) does not match dim!') u,s,v = svd(randn(dim,dim)) # create a coordinate system v that is not orthogonal but not too skew v = v + .2*rand(dim,dim) - .1 cm1 = dot(inv(v),dot(blockdiag(ev1),v)) cm2 = dot(inv(v),dot(blockdiag(ev2),v)) # create block diagonal matrices return cm1, cm2
def rtssmooth(self,Y): ## initialise xf=self.x0 Pf=self.P0 # filter quantities xfStore =[] PfStore=[] #calculate the weights Wm_i,Wc_i=self.sigma_vectors_weights() for y in Y: #calculate the sigma points matrix, each column is a sigma vector Xi_f_=self.sigma_vectors(xf,Pf) #propogate sigma verctors through non-linearity Xi_f=self.state_equation(Xi_f_) #pointwise multiply by weights and sum along y-axis xf_=pb.sum(Wm_i*Xi_f,1) xf_=xf_.reshape(self.nx,1) #purturbation Xi_purturbation=Xi_f-xf_ weighted_Xi_purturbation=Wc_i*Xi_purturbation Pf_=pb.dot(Xi_purturbation,weighted_Xi_purturbation.T)+self.Sigma_e #measurement update equation Pyy=dots(self.C,Pf_,self.C.T)+self.Sigma_varepsilon Pxy=pb.dot(Pf_,self.C.T) K=pb.dot(Pxy,pb.inv(Pyy)) yf_=pb.dot(self.C,xf_) xf=xf_+pb.dot(K,(y-yf_)) Pf=pb.dot((pb.eye(self.nx)-pb.dot(K,self.C)),Pf_) xfStore.append(xf) PfStore.append(Pf) # initialise the smoother T=len(Y) xb = [None]*T Pb = [None]*T xb[-1], Pb[-1] = xfStore[-1], PfStore[-1] # backward iteration for t in range(T-2,-1,-1): #calculate the sigma points matrix from filterd states, each column is a sigma vector Xi_b_=self.sigma_vectors(xfStore[t],PfStore[t]) #propogate sigma verctors through non-linearity Xi_b=self.state_equation(Xi_b_) #calculate xb_ #pointwise multiply by weights and sum along y-axis xb_=pb.sum(Wm_i*Xi_b,1) xb_=xb_.reshape(self.nx,1) #purturbation Xi_b__purturbation=Xi_b_-xfStore[t] Xi_b_purturbation=Xi_b-xb_ #weighting weighted_Xi_b__purturbation=Wc_i*Xi_b__purturbation weighted_Xi_b_purturbation=Wc_i*Xi_b_purturbation Pb_=pb.dot(Xi_b_purturbation,weighted_Xi_b_purturbation.T)+self.Sigma_e Mb_=pb.dot(weighted_Xi_b__purturbation,Xi_b_purturbation.T) #Calculate Smoother outputs S=pb.dot(Mb_,pb.inv(Pb_)) xb[t]=xfStore[t]+pb.dot(S,(xb[t+1]-xb_)) Pb[t]=PfStore[t]+dots(S,(Pb[t+1]-Pb_),S.T) return xb,Pb
''' Created on Jun 5, 2016 @author: ahanagrawal ''' from GradientDescent import ConstructArrays import pylab import numpy as np if __name__ == '__main__': array = pylab.loadtxt("ex1/ex1data1.txt", dtype = float, delimiter = ",") X,Y = ConstructArrays(array) X = np.matrix(X) Y = np.matrix(Y) print(pylab.inv(X.T*X) * X.T * Y)
def Global_Stiffness(self): ''' Generates Global Stiffness Matrix for the plane structure ''' elem = self.element; B = py.zeros((6,6)) for i in range (0,py.size(elem,0)): #for each element find the stifness matrix K = py.zeros((self.n_nodes*2,self.n_nodes*2)) el = elem[i] #nodes formatted for input [node1, node2, node3] = el; node1x = 2*(node1);node2x = 2*(node2);node3x = 2*(node3); node1y = 2*(node1)+1;node2y = 2*(node2)+1;node3y = 2*(node3)+1; #Area, Strain Matrix and E Matrix multiplied to get element stiffness [J,B] = self.B(el) local_k =0.5*abs(J)*py.dot(py.transpose(B),py.dot(self.E_matrix,B)) if self.debug: print 'K for elem', el, '\n', local_k #Element K-Matrix converted into Global K-Matrix format K[py.ix_([node1x,node1y,node2x,node2y,node3x,node3y],[node1x,node1y,node2x,node2y,node3x,node3y])] += local_k #Adding contibution into Global Stiffness self.k_global += K if self.debug: print 'Global Stiffness','\n', self.k_global, '\n', 'size', py.shape(self.k_global), '\n Symmetry test' , py.dot(py.inv(self.k_global),self.k_global)
def dia(r, i, k, w=None, verbose=False, noback=False): """ Computational tool for Difference Image Analysis (DIA) :INPUTS: R -- reference image. This should have the highest possible signal-to-noise and the sharpest PSF. I -- Current image to be analysed. k -- 2D kernel basis mask: 1 for pixels to be used, 0 for pixels to be ignored :OPTIONS: w -- weights of the pixel values in I; typically (sigma)^-2 noback -- do not fit for a variable background; assume constant. verbose -- Print output statements and make a plot or two :OUTPUTS: (M, K, B, C): M -- R, convolved to match I K -- kernel used in convolution B -- background offset C -- chisquared of fit. If no weights were specified, weights are set to unity for this calculation. :EXAMPLE: :: import pylab as py import dia # Define reference and blurred images: ref = py.zeros((10,10)) img = py.zeros((10,10)) ref[3,3] = 1; ref[3,6] = 1; ref[6,3] = 1 img[2,3] = 1; img[3,2:5] = 1; img[4,3] = 1 img[2,6] = 1; img[3,5:8] = 1; img[4,6] = 1 img[5,3] = 1; img[6,2:5] = 1; img[7,3] = 1 # Add some noise: img += py.randn(10, 10)/10. # Define kernel basis kb = py.ones((3,3)) # Compute Difference Image Analysis: m, kern, bkg, chisq = dia.dia(ref, img, kb) # Display results: py.figure() py.subplot(231) py.imshow(ref) py.title('Reference image') py.subplot(232) py.imshow(img) py.title('Observed image') py.subplot(234) py.imshow(kern) py.title('Optimal kernel') py.subplot(235) py.imshow(m) py.title('Convolved Reference') py.subplot(236) py.imshow(img - m) py.title('Residuals') :NOTES: Best results are obtained with proper registration of the images. Also, beware of edge effects. As a general rule, anything within a kernel width of the edges is suspect. Based on the 2D Bramich (2008) DIA algorithm 2008-11-18 11:12 IJC: Extrapolating from my 1D algorithm 2012-04-03 08:19 IJMC: Added example to documentation. """ # """Testing Bramich's algorithm for 2D DIA.""" from nsdata import imshow if noback: if verbose: print "Not fitting for a variable background..." tol = 1e-10 # tolerance for singularity r = array(r, copy=True) i = array(i, copy=True) k = array(k, copy=True, dtype=bool) if len(k.ravel())==1: k = k.reshape((1,1)) elif len(k.shape)==1: k = k.reshape((k.shape[0], 1)) Nrx = r.shape[0] Nry = r.shape[1] Nr = Nrx * Nry Nkx = k.shape[0] Nky = k.shape[1] Nk = k.sum() dx = int(floor(Nkx/2)) dy = int(floor(Nky/2)) ix = Nrx - Nkx + 1 iy = Nry - Nky + 1 pvec = find(k.ravel()) pl = pvec/Nkx pm = pvec % Nky if w==None: w = ones(i.shape, dtype=float) #ind = arange(Nr-Nk+1, dtype=int) if verbose: print "Nrx,Nry,Nr>>" + str((Nrx,Nry,Nr)) print "r>>" + str(r) print "i>>" + str(i) print "Nkx,Nky,Nk>>" + str((Nkx,Nky,Nk)) print "k>>" + str(k) print "pvec>>" + str(pvec) print "pl>>" + str(pl) print "pm>>" + str(pm) print "dx,dy>>" + str((dx,dy)) print "ix,iy>>" + str((ix,iy)) #b = zeros(Nk+1, dtype=float) #for ii in arange(Nk): # b[ii] = (w[ind+dx] * i[ind+dx] * r[ind+ii]).sum() #b[Nk] = (w[ind+dx] * i[ind+dx]).sum() b = zeros(Nk+1, dtype=float) itemp = i[dx:dx+ix,dy:dy+iy] wtemp = w[dx:dx+ix,dy:dy+iy] if verbose: print "itemp>>" + str(itemp) for ii in arange(Nk): b[ii] = (itemp * wtemp * r[pl[ii]:pl[ii]+ix,pm[ii]:pm[ii]+iy]).sum() b[Nk] = (w[dx:dx+ix] * i[dx:dx+ix]).sum() if verbose: print "b>>" + str(b) if verbose: print "Made it through 'b' Calculation!" U = zeros((Nk+1,Nk+1)) # This is optimized by only computing the upper diagonal elements... for ii in arange(Nk): l = pl[ii] m = pm[ii] if verbose: print "l, m>>" + str((l,m)) rwtemp = r[l :l +ix,m :m +ix] * wtemp U[Nk, ii] = rwtemp.sum() U[ii, Nk] = U[Nk, ii] for jj in arange(ii,Nk): l2 = pl[jj] m2 = pm[jj] if verbose: print "l2, m2>>" + str((l2,m2)) U[ii,jj] = ( rwtemp * r[l2:l2+ix,m2:m2+ix] ).sum() U[jj,ii] = U[ii,jj] if verbose: print "U>>" + str(U) U[Nk, Nk] = wtemp.sum() if verbose: print "U>>" + str(U) if noback: U = U[0:Nk, 0:Nk] b = b[0:Nk] detU = linalg.det(U) if verbose: print "det(U) is: " + str(detU) if detU<tol: if verbose: print "Singular matrix: det(U) < tol. Using pseudoinverse..." a = dot(linalg.pinv(U), b) else: a = dot(inv(U), b) if noback: K = a B0 = 0.0 else: K = a[0:len(a)-1] B0 = a[-1] if verbose: print "K>>" + str(K) if verbose: print "B0>>" + str(B0) if verbose: print "find(k.ravel())>>" + str(find(k.ravel())) kernel = zeros(Nkx*Nky, dtype=float) kernel[find(k.ravel())] = K kernel = kernel.reshape((Nkx, Nky)) # Bramich's convolution is not Numpy-standard, so we do it by hand: m = rconvolve2d(r, kernel, mode='valid') + B0 if verbose: print "itemp.shape>>" + str(itemp.shape) if verbose: print "wtemp.shape>>" + str(wtemp.shape) if verbose: print "r.shape>>" + str(r.shape) if verbose: print "m.shape>>" + str(m.shape) if verbose: print "m[dx:dx+ix,dy:dy+iy].shape>>" + str(m[dx:dx+ix,dy:dy+iy].shape) chisq = ( wtemp * (itemp - m[dx:dx+ix,dy:dy+iy])**2 ).sum() chisq0 = ( wtemp * (itemp - r[dx:dx+ix,dy:dy+iy])**2 ).sum() #if verbose: print "Kernel is: " + str(kernel) if verbose: print "Background: " + str(B0) if verbose: print "Phot. scaling: " + str(kernel.sum()) if verbose: print "For the (" + str(Nr) + " - " + str(Nk+1) + ") = " + str(Nr-Nk-1) + " DOF:" if verbose: print "Red. Chisquared (I-R): " + str(chisq0/(Nr-Nk-1)) if verbose: print "Red. Chisquared (I-M): " + str(chisq/(Nr-Nk-1)) if verbose: figure(); cmin = array([i.min(), m.min()]).min() cmax = array([i.max(), m.max()]).max() subplot(131); imshow(r); title('R'); clim([cmin, cmax]); colorbar() subplot(132); imshow(i); title('I'); clim([cmin, cmax]); colorbar() subplot(133); imshow(m); title('M'); clim([cmin, cmax]); colorbar() figure(); cmin = array([(r-i).min(), (m-i).min()]).min() cmax = array([(r-i).max(), (m-i).min()]).max() subplot(121); imshow(r - i); title('R - I'); clim([cmin, cmax]); colorbar(); subplot(122); imshow(m - i); title('M - I'); clim([cmin, cmax]); colorbar(); figure(); imshow(kernel); title('Kernel'); colorbar() show() return (m, kernel, B0, chisq)
def solve_inv(A, B): return pl.inv(A) * B
def rtssmooth(self,Y): """Rauch Tung Streibel(RTS) smoother Arguments ---------- Y : list of ndarray list of observation vectors Returns ---------- XStore : list of ndarray list of forward state estimates PStore : list of ndarray list of forward state covariance matrices XbStore : list of ndarray list of backward state estimates PbStore : list of ndarray list of backward state covariance matrices """ # prediction def Kpred(A,P,Sigma_e,x): if (np.rank(A)!=2 or type(self.A)!=np.ndarray):raise TypeError('A should be rank two array') if (np.rank(Sigma_e)!=2 or type(self.Sigma_e)!=np.ndarray):raise TypeError('Sigma_e should be rank two array') if (np.rank(P)!=2 or type(self.Sigma_e)!=np.ndarray):raise TypeError('P should be rank two array') if type(x)!=np.ndarray:raise TypeError('x0 should be rank two array') # predict state x_ = pb.dot(A,x) # predict state covariance P_ =dots(A,P,A.T) + Sigma_e return x_,P_ # correction def Kupdate(A,C,P_,Sigma_epsilon,x_,y): if (np.rank(A)!=2 or type(self.A)!=np.ndarray):raise TypeError('A should be rank two array') if (np.rank(C)!=2 or type(self.C)!=np.ndarray):raise TypeError('C should be rank two array') if (np.rank(Sigma_epsilon)!=2 or type(self.Sigma_epsilon)!=np.ndarray):raise TypeError('Sigma_epsilon should be rank two array') if (np.rank(P_)!=2 or type(P_)!=np.ndarray):raise TypeError('P should be rank two array') if type(x_)!=np.ndarray:raise TypeError('x0 should be rank two array') if type(y)!=np.ndarray:raise TypeError('y should be rank two array') # calculte Kalman gain K =pb.dot(pb.dot(P_,C.T),pb.inv(dots(C,P_,C.T) + Sigma_epsilon)) # update estimate with model output measurement x = x_ + pb.dot(K,(y-pb.dot(C,x_))) # update the state error covariance P = pb.dot((np.eye(self.nx)-pb.dot(K,C)),P_); return x,P,K # smoother quantities XStore_ =pb.zeros([len(Y),self.nx]) PStore_ =pb.zeros([len(Y),self.nx**2]) XStore = pb.zeros([len(Y),self.nx]) PStore = pb.zeros([len(Y),self.nx**2]) x_,P_ = Kpred(self.A,self.P0,self.Sigma_e,self.x0) # filter for i in range(len(Y)): #store predicted states PStore_[i,:]=P_.ravel() XStore_[i,:]=x_.ravel() # update state estimate with measurement and stored Kalman gain x,P,K= Kupdate(self.A,self.C,P_,self.Sigma_epsilon,x_,Y[i]) # store corrected states and covariance matrices XStore[i,:]=x.ravel() PStore[i,:]=P.ravel() # predict new state x_, P_ = Kpred(self.A,P,self.Sigma_e,x) # initialise the smoother T=len(Y) XbStore = pb.zeros([T,self.nx]) PbStore = pb.zeros([T,self.nx**2]) S = pb.zeros([T,self.nx**2]) XbStore[-1,:], PbStore[-1,:] = XStore[-1,:], PStore[-1,:] # RTS smoother for t in range(T-2,-1,-1): S_temp= dots(PStore[t,:].reshape(self.nx,self.nx),self.A.T,pb.inv(PStore_[t+1,:].reshape(self.nx,self.nx))) S[t,:]=S_temp.ravel() XbStore_temp= XStore[t,:].reshape(self.nx,1) + pb.dot(S_temp,(XbStore[t+1].reshape(self.nx,1) - XStore_[t+1,:].reshape(self.nx,1))) XbStore[t,:]=XbStore_temp.ravel() PbStore_temp = PStore[t,:].reshape(self.nx,self.nx) + dots(S_temp,PbStore[t+1,:].reshape(self.nx,self.nx)-PStore_[t+1,:].reshape(self.nx,self.nx),S_temp.T) PbStore[t,:]=PbStore_temp.ravel() # iterate a final time to calucate the cross covariance matrices M = pb.zeros([T,self.nx**2]) M[-1,:]=pb.dot(np.eye(self.nx)-pb.dot(K,self.C), pb.dot(self.A,PStore[-2,:].reshape(self.nx,self.nx))).ravel() for t in range(T-2,0,-1): M_temp=pb.dot(PStore[t,:].reshape(self.nx,self.nx),S[t-1,:].reshape(self.nx,self.nx).T) + dots(S[t,:].reshape(self.nx,self.nx),M[t+1,:].reshape(self.nx,self.nx) - pb.dot(self.A,PStore[t,:].reshape(self.nx,self.nx)),S[t-1].reshape(self.nx,self.nx).T) M[t,:]=M_temp.ravel() return XbStore,PbStore,M
if listener.msg_ok: H = listener.H.copy() A = listener.A.copy() B = listener.B.copy() # get vertices vert = [] for i in xrange(7): for j in xrange(i + 1, 8): #xrange(8): #if i != j: for u in [A[i], B[i]]: for v in [A[j], B[j]]: # intersection of Ai = Hi.x and Bj = Hj.x x = pl.dot(pl.inv(H[[i, j], :]), pl.array([u, v])) # check constraints: A <= H.x <= B if pl.amin(pl.dot(H, x) - A) >= -1e-6 and pl.amax( pl.dot(H, x) - B) <= 1e-6: vert.append(x.reshape(2).copy()) print('the number of vertices', len(vert)) # continue only if enough vertices if len(vert) > 2: ax.clear() inter = inter + 1 vert_uns = pl.array(vert + [vert[0]]) xm, xM, ym, yM = pl.amin(vert_uns[:, 0]), pl.amax( vert_uns[:, 0]), pl.amin(vert_uns[:, 1]), pl.amax(vert_uns[:,
def fit_consistent(model, iter=2000, burn=1000, thin=1, tune_interval=100, verbose=False): """Fit data model for all epidemiologic parameters using MCMC :Parameters: - `model` : data.ModelData - `iter` : int, number of posterior samples fit - `burn` : int, number of posterior samples to discard as burn-in - `thin` : int, samples thinned by this number - `tune_interval` : int - `verbose` : boolean :Results: - returns a pymc.MCMC object created from vars, that has been fit with MCMC .. note:: - `burn` must be less than `iter` - `thin` must be less than `iter` minus `burn` """ assert burn < iter, 'burn must be less than iter' assert thin < iter - burn, 'thin must be less than iter-burn' param_types = 'i r f p pf rr smr m_with X'.split() vars = model.vars start_time = time.time() map = mc.MAP(vars) m = mc.MCMC(vars) ## use MAP to generate good initial conditions try: method='fmin_powell' tol=.001 fit_model.logger.info('fitting submodels') fit_model.find_consistent_spline_initial_vals(vars, method, tol, verbose) for t in param_types: fit_model.find_re_initial_vals(vars[t], method, tol, verbose) fit_model.logger.info('.') fit_model.find_consistent_spline_initial_vals(vars, method, tol, verbose) fit_model.logger.info('.') for t in param_types: fit_model.find_fe_initial_vals(vars[t], method, tol, verbose) fit_model.logger.info('.') fit_model.find_consistent_spline_initial_vals(vars, method, tol, verbose) fit_model.logger.info('.') for t in param_types: fit_model.find_dispersion_initial_vals(vars[t], method, tol, verbose) fit_model.logger.info('.') fit_model.logger.info('\nfitting all stochs\n') map.fit(method=method, tol=tol, verbose=verbose) if verbose: from fit_posterior import inspect_vars print inspect_vars({}, vars) except KeyboardInterrupt: fit_model.logger.warning('Initial condition calculation interrupted') ## use MCMC to fit the model try: fit_model.logger.info('finding step covariances') vars_to_fit = [[vars[t].get('p_obs'), vars[t].get('pi_sim'), vars[t].get('smooth_gamma'), vars[t].get('parent_similarity'), vars[t].get('mu_sim'), vars[t].get('mu_age_derivative_potential'), vars[t].get('covariate_constraint')] for t in param_types] max_knots = max([len(vars[t]['gamma']) for t in 'irf']) for i in range(max_knots): stoch = [vars[t]['gamma'][i] for t in 'ifr' if i < len(vars[t]['gamma'])] if verbose: print 'finding Normal Approx for', [n.__name__ for n in stoch] try: na = mc.NormApprox(vars_to_fit + stoch) na.fit(method='fmin_powell', verbose=verbose) cov = pl.array(pl.inv(-na.hess), order='F') if pl.all(pl.eigvals(cov) >= 0): m.use_step_method(mc.AdaptiveMetropolis, stoch, cov=cov) else: raise ValueError except ValueError: if verbose: print 'cov matrix is not positive semi-definite' m.use_step_method(mc.AdaptiveMetropolis, stoch) fit_model.logger.info('.') for t in param_types: fit_model.setup_asr_step_methods(m, vars[t], vars_to_fit) # reset values to MAP fit_model.find_consistent_spline_initial_vals(vars, method, tol, verbose) fit_model.logger.info('.') map.fit(method=method, tol=tol, verbose=verbose) fit_model.logger.info('.') except KeyboardInterrupt: fit_model.logger.warning('Initial condition calculation interrupted') fit_model.logger.info('\nsampling from posterior distribution\n') m.iter=iter m.burn=burn m.thin=thin if verbose: try: m.sample(m.iter, m.burn, m.thin, tune_interval=tune_interval, progress_bar=True, progress_bar_fd=sys.stdout) except TypeError: m.sample(m.iter, m.burn, m.thin, tune_interval=tune_interval, progress_bar=False, verbose=verbose) else: m.sample(m.iter, m.burn, m.thin, tune_interval=tune_interval, progress_bar=False) m.wall_time = time.time() - start_time model.map = map model.mcmc = m return model.map, model.mcmc
def create_cm(dim, eigList1=None, eigList2=None): """ returns two real-valued commuting matrices of dimension dim x dim the eigenvalues of each matrix can be given; single complex numbers will be interpreted as pair of complex conjuates. With this restriction, the (internally augmented) lists must have the length of dim """ if eigList1 is None: eigList1 = rand(dim) if eigList2 is None: eigList2 = rand(dim) # order 1st array such that complex numbers are first EL1 = array(eigList1) imPos1 = find(iscomplex(EL1)) rePos1 = find(isreal(EL1)) # shorter than set comparisons :D EL1 = hstack([EL1[imPos1], EL1[rePos1]]) # order 2nd array such that complex numbers are last EL2 = array(eigList2) imPos2 = find(iscomplex(EL2)) rePos2 = find(isreal(EL2)) # shorter than set comparisons :D EL2 = hstack([EL2[rePos2], EL2[imPos2]]) # now: make eigenvalues of list #2, where a block is in list #1, # pairwise equal, and other way round EL2[1:2 * len(imPos1):2] = EL2[0:2 * len(imPos1):2] EL1[-2 * len(imPos2) + 1::2] = EL1[-2 * len(imPos2)::2] if len(imPos2) * 2 + len(imPos1) * 2 > dim: raise ValueError( 'too many complex eigenvalues - cannot create commuting matrices') # augment lists ev1 = [] nev1 = 0 for elem in EL1: if elem.imag != 0.: ev1.append(array([[elem.real, -elem.imag], [elem.imag, elem.real]])) nev1 += 2 else: ev1.append(elem) nev1 += 1 if nev1 != dim: raise ValueError( 'number of given eigenvalues #1 (complex: x2) does not match dim!') ev2 = [] nev2 = 0 for elem in EL2: if elem.imag != 0.: ev2.append(array([[elem.real, -elem.imag], [elem.imag, elem.real]])) nev2 += 2 else: ev2.append(elem) nev2 += 1 if nev2 != dim: raise ValueError( 'number of given eigenvalues #2 (complex: x2) does not match dim!') u, s, v = svd(randn(dim, dim)) # create a coordinate system v that is not orthogonal but not too skew v = v + .2 * rand(dim, dim) - .1 cm1 = dot(inv(v), dot(blockdiag(ev1), v)) cm2 = dot(inv(v), dot(blockdiag(ev2), v)) # create block diagonal matrices return cm1, cm2
def dialin(r, i, k, w=None, verbose=True, noback=False): """ Computational tool for Difference Image Analysis (DIA) with a linearly-varying kernel :INPUTS: R -- reference image. This should have the highest possible signal-to-noise and the sharpest PSF. I -- Current image to be analysed. k -- pixel mask for kernel; 1 for pixels to be used, 0 for pixels to be ignored :OPTIONS: w -- weights of the pixel values in I; typically (sigma)^-2 noback -- do not fit for a variable background; assume constant. verbose -- Print output statements and make a plot or two :OUTPUTS: (M, K, X, Y, B, C): M -- R, convolved to match I K -- kernel used in convolution B -- background offset C -- chisquared of fit. If no weights were specified, weights are set to unity for this calculation. :NOTES: Best results are obtained with proper registration of the images. Also, beware of edge effects. As a general rule, anything within a kernel width of the edges is suspect. Originally based on the 2D Bramich (2008) DIA algorithm 2008-11-19 21:50 IJC: Trying it out """ # """Testing Bramich's algorithm for 2D DIA.""" from nsdata import imshow if noback: if verbose: print "Not fitting for a variable background..." tol = 1e-10 # tolerance for singularity r = array(r, copy=True) i = array(i, copy=True) k = array(k, copy=True, dtype=bool) if len(k.ravel())==1: k = k.reshape((1,1)) elif len(k.shape)==1: k = k.reshape((k.shape[0], 1)) Nrx = r.shape[0] Nry = r.shape[1] Nr = Nrx * Nry Nkx = k.shape[0] Nky = k.shape[1] Nk = k.sum() dx = int(floor(Nkx/2)) dy = int(floor(Nky/2)) ix = Nrx - Nkx + 1 iy = Nry - Nky + 1 pvec = find(k.ravel()) pl = pvec/Nkx pm = pvec % Nky if w==None: w = ones(i.shape, dtype=float) #ind = arange(Nr-Nk+1, dtype=int) if verbose: print "Nrx,Nry,Nr>>" + str((Nrx,Nry,Nr)) if verbose: print "r>>" + str(r) if verbose: print "i>>" + str(i) if verbose: print "Nkx,Nky,Nk>>" + str((Nkx,Nky,Nk)) if verbose: print "k>>" + str(k) if verbose: print "pvec>>" + str(pvec) if verbose: print "pl>>" + str(pl) if verbose: print "pm>>" + str(pm) if verbose: print "dx,dy>>" + str((dx,dy)) if verbose: print "ix,iy>>" + str((ix,iy)) xcoords = arange(Nrx) - floor(Nrx/2) ycoords = arange(Nry) - floor(Nry/2) xx,yy = meshgrid(xcoords, ycoords) if verbose: print "xx>>" + str(xx) if verbose: print "yy>>" + str(yy) b = zeros(3*Nk+1, dtype=float) itemp = i[dx:dx+ix,dy:dy+iy] wtemp = w[dx:dx+ix,dy:dy+iy] iwtemp = itemp * wtemp #xtemp = xx[dx:dx+ix,dy:dy+iy] #ytemp = yy[dx:dx+ix,dy:dy+iy] if verbose: print "itemp>>" + str(itemp) #if verbose: print "xtemp>>" + str(ytemp) #if verbose: print "ytemp>>" + str(xtemp) for ii in arange(Nk): l = pl[ii] m = pm[ii] b[ii] = (iwtemp * r[l:l+ix,m:m+iy]).sum() b[ii+Nk] = (iwtemp * r[l:l+ix,m:m+iy] * xx[l:l+ix,m:m+iy]).sum() b[ii+2*Nk] = (iwtemp * r[l:l+ix,m:m+iy] * yy[l:l+ix,m:m+iy]).sum() b[3*Nk] = iwtemp.sum() if verbose: print "b>>" + str(b) if verbose: print "Made it through 'b' Calculation!" # Construct the U_pq matrix; here p is "ii" and q is "jj" U = zeros((3*Nk+1,3*Nk+1)) for ii in arange(Nk): l = pl[ii] m = pm[ii] xtemp = xx[l:l+ix,m:m+iy] ytemp = yy[l:l+ix,m:m+iy] rtemp = r[l:l+ix, m:m+iy] #if verbose: print "xtemp.shape>>" + str(xtemp.shape) #if verbose: print "ytemp.shape>>" + str(ytemp.shape) # Compute the final row and column: U[ii,-1] = ( wtemp * rtemp ).sum() U[-1,ii] = U[ii,-1] U[ii+Nk,-1] = ( wtemp * rtemp * xtemp ).sum() U[-1,ii+Nk] = U[ii+Nk,-1] U[ii+2*Nk,-1] = ( wtemp * rtemp * ytemp ).sum() # Compute the guts of the matrix: for jj in arange(ii+1): l2 = pl[jj] m2 = pm[jj] if verbose: print "ii,jj, l, m, l2, m2>>" + str((ii,jj,l,m,l2,m2)) xtemp2 = xx[l2:l2+ix,m2:m2+iy] ytemp2 = yy[l2:l2+ix,m2:m2+iy] rtemp2 = r[l2:l2+ix, m2:m2+iy] #if verbose: print "xtemp2.shape>>" + str(xtemp2.shape) #if verbose: print "ytemp2.shape>>" + str(ytemp2.shape) wrr2 = wtemp * rtemp * rtemp2 U[ii,jj] = ( wrr2 ).sum() U[ii+Nk,jj] = ( wrr2 * xtemp ).sum() U[ii+Nk,jj+Nk] = ( wrr2 * xtemp * xtemp2 ).sum() U[ii+2*Nk,jj] = ( wrr2 * ytemp ).sum() U[ii+2*Nk,jj+Nk] = ( wrr2 * ytemp * xtemp2 ).sum() U[ii+2*Nk,jj+2*Nk] = ( wrr2 * ytemp * ytemp2 ).sum() if ii>jj: # Fill out the upper diagonal: if verbose: print "Filling upper diag. component " + str((ii,jj)) U[jj ,ii ] = U[ii ,jj ] U[jj ,ii+Nk ] = U[ii+Nk ,jj ] U[jj+Nk ,ii+Nk ] = U[ii+Nk ,jj+Nk ] U[jj ,ii+2*Nk] = U[ii+2*Nk,jj ] U[jj+Nk ,ii+2*Nk] = U[ii+2*Nk,jj+Nk ] U[jj+2*Nk,ii+2*Nk] = U[ii+2*Nk,jj+2*Nk] U[-1,-1] = wtemp.sum() if verbose: print "U>>" + str(U) if noback: U = U[0:3*Nk, 0:3*Nk] b = b[0:3*Nk] detU = linalg.det(U) if verbose: print "det(U) is: " + str(detU) if detU<tol: if verbose: print "Singular matrix: det(U) < tol. Using pseudoinverse..." a = dot(linalg.pinv(U), b) else: a = dot(inv(U), b) if noback: K = a B0 = 0.0 else: K = a[0:len(a)-1] B0 = a[-1] if verbose: print "K>>" + str(K) if verbose: print "B0>>" + str(B0) if verbose: print "find(k.ravel())>>" + str(find(k.ravel())) kernel = zeros(Nkx*Nky, dtype=float) xkernel = zeros(Nkx*Nky, dtype=float) ykernel = zeros(Nkx*Nky, dtype=float) kernel[find(k.ravel())] = K[0:Nk] xkernel[find(k.ravel())] = K[Nk:2*Nk] ykernel[find(k.ravel())] = K[2*Nk:3*Nk] kernel = kernel.reshape((Nkx, Nky)) xkernel = xkernel.reshape((Nkx, Nky)) ykernel = ykernel.reshape((Nkx, Nky)) # Bramich's convolution is not Numpy-standard, so we do it by hand: #m = rconvolve2d(r, kernel, mode='valid') + B0 #chisq = ( wtemp * (itemp - m[dx:dx+ix,dy:dy+iy])**2 ).sum() #chisq0 = ( wtemp * (itemp - r[dx:dx+ix,dy:dy+iy])**2 ).sum() if verbose: print "Kernel is: " + str(kernel) if verbose: print "X-Kernel is: " + str(xkernel) if verbose: print "Y-Kernel is: " + str(ykernel) if verbose: print "Background: " + str(B0) if verbose: print "Phot. scaling: " + str(kernel.sum()) if verbose: print "For the (" + str(Nr) + " - " + str(3*Nk+1) + ") = " + str(Nr-3*Nk-1) + " DOF:" #if verbose: print "Red. Chisquared (I-R): " + str(chisq0/(Nr-Nk-1)) #if verbose: print "Red. Chisquared (I-M): " + str(chisq/(Nr-Nk-1)) if verbose: ndim=3 for ii in range(ndim): for jj in range(ndim): figure(1); s = subplot(ndim, ndim, 1+jj + (ndim-ii-1)*ndim) xind = int(Nrx/(ndim+1.0)) yind = int(Nry/(ndim+1.0)) x0 = xx[(ii+1)*xind,(jj+1)*yind] y0 = yy[(ii+1)*xind,(jj+1)*yind] print "x0,y0>>" + str((x0,y0)) imshow(kernel + x0*xkernel + y0*ykernel) s.set_ylim(s.get_ylim()[::-1]) offset = array(centroid(kernel + x0*xkernel + y0*ykernel)) - \ array(centroid(ones(kernel.shape))) title(str((x0,y0)) + ': ' + str(offset)) #figure(2) #plot([x0],[y0], 'oc') #plot([x0, x0+offset[0]], [y0, y0+offset[1]], '-k') figure(); subplot(121); imshow(r); title('Reference'); #clim([cmin, cmax]); colorbar() subplot(122); imshow(i); title('Current Image'); #clim([cmin, cmax]); colorbar() #subplot(133); imshow(m); title('M'); clim([cmin, cmax]); colorbar() # figure(); # cmin = array([(r-i).min(), (m-i).min()]).min() # cmax = array([(r-i).max(), (m-i).min()]).max() # subplot(121); imshow(r - i); title('R - I'); clim([cmin, cmax]); colorbar(); # subplot(122); imshow(m - i); title('M - I'); clim([cmin, cmax]); colorbar(); show() return
def gen_ssmodel(self): '''Generates non-linear, Integro-Difference, discrete-time state space model. Atributes: ---------- Gamma: ndarray Inner product of field basis functions Gamma_inv: ndarray Inverse of Gamma Sigma_e: ndarray Covariance matrix of the field disturbance Sigma_e_inv: ndarray Inverse of Sigma_e Sigma_e_c: ndarray cholesky decomposiotion of field disturbance covariance matrix Sigma_varepsilon_c: ndarray cholesky decomposiotion of observation noise covariance matrix Phi_values: ndarray nx by number of spatial locations field basis functions values over the spatial field psi_conv_Phi_values: ndarray ; each ndarray is nx by number of spatial locations convolution of the connectivity kernel basis functions with the field basis functions evaluate over space Gamma_inv_psi_conv_Phi:ndarray; each ndarray is nx by number of spatial locations the product of inverse gamme withe psi0_conv_Phi C: ndarray Observation matrix Gamma_inv_Psi_conv_Phi: ndarray nx by number of spatial locations the convolution of the kernel with field basis functions at discritized spatial points ''' #Generate Gamma if hasattr(self,'Gamma'): pass else: t_total=time.time() #calculate Gamma=PhixPhi.T; inner product of the field basis functions Gamma=pb.dot(self.field.Phi,self.field.Phi.T) Gamma_inv=pb.inv(Gamma) self.Gamma=Gamma.astype('float') self.Gamma_inv=Gamma_inv #Generate field covariance matrix if hasattr(self,'Sigma_e'): pass else: gamma_convolution_vecrorized=pb.vectorize(self.gamma.conv) gamma_conv_Phi=gamma_convolution_vecrorized(self.field.Phi).T #[gamma*phi1 gamma*phi2 ... gamma*phin] 1 by nx Pi=pb.dot(self.field.Phi,gamma_conv_Phi) #nx by nx ndarray Pi=Pi.astype('float') Sigma_e=pb.dot(pb.dot(self.gamma_weight*Gamma_inv,Pi),Gamma_inv.T) Sigma_e_c=sp.linalg.cholesky(Sigma_e,lower=1) self.Sigma_e=Sigma_e self.Sigma_e_inv=pb.inv(Sigma_e) self.Sigma_e_c=Sigma_e_c Sigma_varepsilon_c=sp.linalg.cholesky(self.Sigma_varepsilon,lower=1) self.Sigma_varepsilon_c=Sigma_varepsilon_c if hasattr(self,'Phi_values'): pass else: #Generate field meshgrid estimation_field_space_x,estimation_field_space_y=pb.meshgrid(self.estimation_space_x_y,self.estimation_space_x_y) estimation_field_space_x=estimation_field_space_x.ravel() estimation_field_space_y=estimation_field_space_y.ravel() #calculate Phi_values #Phi_values is like [[phi1(r1) phi1(r2)...phi1(rn_r)],[phi2(r1) phi2(r2)...phi2(rn_r)],..[phiL(r1) phiL(r2)...phiL(rn_r)]] Phi_values=[self.field.Phi[i,0](estimation_field_space_x,estimation_field_space_y) for i in range(self.nx)] self.Phi_values=pb.squeeze(Phi_values) #it's nx by number of apatial points #vectorizing kernel convolution method psi_convolution_vectorized=pb.empty((self.n_theta,1),dtype=object) for i in range(self.n_theta): psi_convolution_vectorized[i,0]=pb.vectorize(self.kernel.Psi[i].conv) #find convolution between kernel and field basis functions analytically psi_conv_Phi=pb.empty((self.nx,self.n_theta),dtype=object)#nx by n_theta for i in range(self.n_theta): psi_conv_Phi[:,i]=psi_convolution_vectorized[i,0](self.field.Phi).ravel() #ecaluate convolution between kernel and field basis functions at spatial locations psi_conv_Phi_values=pb.empty((self.n_theta,self.nx,len(self.estimation_space_x_y)**2),dtype=float) for i in range(self.n_theta): for j in range(self.nx): psi_conv_Phi_values[i,j,:]=psi_conv_Phi[j,i](estimation_field_space_x,estimation_field_space_y) self.psi_conv_Phi_values=psi_conv_Phi_values self.Gamma_inv_psi_conv_Phi=pb.dot(self.Gamma_inv,self.psi_conv_Phi_values) #Calculate observation matrix if hasattr(self,'C'): pass else: #Generate Observation locations grid obs_locns_x=self.obs_locns[:,0] obs_locns_y=self.obs_locns[:,1] sensor_kernel_convolution_vecrorized=pb.vectorize(self.sensor_kernel.conv) sensor_kernel_conv_Phi=sensor_kernel_convolution_vecrorized(self.field.Phi).T #first row #[m*phi_1 m*phi2 ... m*phin] C=pb.empty(([self.ny,self.nx]),dtype=float) for i in range(self.nx): C[:,i]=sensor_kernel_conv_Phi[0,i](obs_locns_x,obs_locns_y) self.C=C print 'Elapsed time in seconds to generate the stat-space model',time.time()-t_total #We need to calculate this bit at each iteration #Finding the convolution of the kernel with field basis functions at discritized spatial points self.Gamma_inv_Psi_conv_Phi=pb.sum(self.kernel.weights[pb.newaxis,:,pb.newaxis]*self.Gamma_inv_psi_conv_Phi,axis=1)
def dsa(r, i, Nk, **kw): #, w=None, verbose=False, noback=False): """ Computational tool for Difference Spectral Analysis (DSA) :INPUTS: R -- reference spectrum. This should have the highest possible signal-to-noise and the highest spectral resolution. I -- Current spectrum to be analysed. Nk -- number of pixels in the desired convolution kernel :OPTIONS: w -- weights of the pixel values in I; typically (sigma)^-2 noback -- do not fit for a variable background; assume constant. tol=1e-10 -- if matrix determinant is less than tol, use pseudoinverse rather than straight matrix inversion verbose -- Print output statements and make a plot or two retinv -- return a fourth output, the Least Squares inverse matrix (False by default) :OUTPUTS: (M, K, B, C): M -- R, convolved to match I K -- kernel used in convolution B -- background offset C -- chisquared of fit. If no weights were specified, weights are set to unity for this calculation. :OPTIONS: I -- inverse matrix :NOTES: Best results are obtained with proper registration of the spectra. Also, beware of edge effects. As a general rule, anything within a kernel width of the edges is suspect. :SEE_ALSO: :func:`dsamulti` """ # """Testing Bramich's algorithm for 1D spectra.""" # Based on the 2D Bramich (2008) DIA algorithm # ----- # 2008-11-14 10:56 IJC: Created @ UCLA. # 2008-11-18 11:12 IJC: Registration now works correctly # 2008-12-09 16:10 IJC: Somewhat optimized # 2009-02-26 22:06 IJC: Added retinv, changed optional input format defaults = dict(verbose=False, w=None, noback=False, tol=1e-10, \ retinv=False) for key in defaults: if (not kw.has_key(key)): kw[key] = defaults[key] verbose = bool(kw['verbose']) noback = bool(kw['noback']) retinv = bool(kw['retinv']) w = kw['w'] if verbose: print "kw>>" + str(kw) if noback: if verbose: print "Not fitting for a variable background..." tol = 1e-10 # tolerance for singularity r = array(r, copy=True) i = array(i, copy=True) dx = int(floor(Nk/2)) Nk = int(Nk) # length of kernel if w==None: w = ones(len(r), dtype=float) Nr = len(r) # length of Referene ind = arange(Nr-Nk+1, dtype=int) wind = w[ind] if verbose: #print "r>>" + str(r) #print "i>>" + str(i) #print "ind>>" + str(ind) print "" if noback: U = zeros((Nk,Nk), dtype=float) b = zeros(Nk, dtype=float) else: U = zeros((Nk+1,Nk+1), dtype=float) b = zeros(Nk+1, dtype=float) # Build the b vector and U matrix tempval0 = w[ind+dx] * i[ind+dx] for p in range(Nk): b[p] = (tempval0 * r[ind+p]).sum() tempval2 = wind*r[ind+p] for q in range(p, Nk): U[p,q] = (tempval2 * r[ind+q]).sum() U[q,p] = U[p,q] if not noback: b[Nk] = (w[ind+dx] * i[ind+dx]).sum() for q in range(Nk): U[Nk, q] = (wind * r[ind+q]).sum() U[q, Nk] = U[Nk, q] U[Nk,Nk] = wind.sum() detU = linalg.det(U) if verbose: print "det(U) is: " + str(detU) if detU<tol: print "Singular matrix: det(U) < tol. Using pseudoinverse..." if verbose: print 'U>>',U invmat = linalg.pinv(U) else: invmat = inv(U) a = dot(invmat, b) if noback: K = a B0 = 0.0 else: K = a[0:len(a)-1] B0 = a[-1] m = rconvolve1d(r, K, mode='valid') + B0 chisq = ( wind * (i[ind] - m[ind])**2 ).sum() if verbose: chisq0 = ( wind * (i[ind] - r[ind])**2 ).sum() #print "Kernel is: " + str(K) print "Background: " + str(B0) print "For the (" + str(Nr) + " - " + str(Nk+1) + ") = " + str(Nr-Nk-1) + " DOF:" print "Red. Chisquared (I-R): " + str(chisq0/(Nr-Nk-1)) print "Red. Chisquared (I-M): " + str(chisq/(Nr-Nk-1)) figure(); subplot(311) plot(r, '--'); plot(i, '-x'); plot(m, '-..'); legend('RIM'); subplot(312); plot(r - i, '--'); plot(m - i); legend(['R-I', 'M-I']) subplot(313); plot(K, '-o'); grid('on'); legend(['Kernel']); if retinv: return (m, K, B0, chisq, invmat) else: return (m, K, B0, chisq)
def gen_ssmodel(self): #calculate U #~~~~~~~~~~~ if not(hasattr(self,'U')): t0=time.time() self.U_Index=[] U=pb.empty((self.nx,self.nx),dtype=object) U_T=pb.empty((self.nx,self.nx),dtype=object) for i in range(self.nx): for j in range(self.nx): u_temp=pb.vectorize(self.field.Mu[j,0].conv)(self.kernel.Lambda) U[i,j]=pb.dot(u_temp.T,self.field.Mu[i,0]).astype(float) U_T[j,i]=U[i,j].T if U[i,j].any(): self.U_Index.append((i,j)) self.U=U self.U_T=U_T print 'Elapsed time in seconds to calculate U is', time.time()-t0 #calculate the inverse of inner product of field basis functions if not(hasattr(self,'Lambda_x_blocks_inverse')): t0=time.time() Lambda_x_blocks_inverse=pb.empty((1,len(self.field.NoatEachLevel)),dtype=object) Lambda_x_inverse_temp=0 for i in range(Lambda_x_blocks_inverse.shape[1]): Lambda_x_blocks_inverse_temp=pb.reshape(self.field.Mu[Lambda_x_inverse_temp:Lambda_x_inverse_temp+self.field.NoatEachLevel[i],0],(1,self.field.NoatEachLevel[i])) Lambda_x_blocks_inverse[0,i]=pb.inv(pb.dot(Lambda_x_blocks_inverse_temp.T,Lambda_x_blocks_inverse_temp)).astype(float) Lambda_x_inverse_temp+=self.field.NoatEachLevel[i] self.Lambda_x_blocks_inverse=Lambda_x_blocks_inverse print 'Elapsed time in seconds to calculate Lambda_x_inverse is',time.time()-t0 #calculate Lambda_x if not(hasattr(self,'Lambda_x')): t0=time.time() Lambda_x=pb.dot(self.field.Mu,self.field.Mu.T) self.Lambda_x=Lambda_x print 'Elapsed time in seconds to calculate Lambda_x is',time.time()-t0 t0=time.time() Lambda_theta = pb.zeros([self.nx,self.nx]) for i in self.U_Index: Lambda_theta[i] = pb.dot(self.U[i],self.kernel.weights) self.Lambda_theta = Lambda_theta #calculate A A_blocks=pb.empty((1,len(self.field.NoatEachLevel)),dtype=object) A_temp=0 for i in range(A_blocks.shape[1]): A_blocks_temp=self.Lambda_theta[A_temp:self.field.NoatEachLevel[i]+A_temp] A_blocks[0,i]=pb.dot(self.Lambda_x_blocks_inverse[0,i],A_blocks_temp) A_temp+=self.field.NoatEachLevel[i] self.A=self.Ts*self.varsigma*pb.vstack(A_blocks[0,:])+self.xi*pb.eye(self.nx) print 'Elapsed time in seconds to calculate Lambda_theta and A is',time.time()-t0 # form the observation matrix if not(hasattr(self,'C')): t0=time.time() t_observation_matrix=time.time() sensor_kernel_convolution_vecrorized=pb.vectorize(self.sensor_kernel.conv) sensor_kernel_conv_Mu=sensor_kernel_convolution_vecrorized(self.field.Mu).T C=pb.empty(([self.ny,self.nx]),dtype=float) for i in range(self.nx): c_temp=pb.vectorize(sensor_kernel_conv_Mu[0,i].__call__) C[:,i]=c_temp(self.obs_locns) self.C=C print 'Elapsed time in seconds to calculate observation matrix C is',time.time()-t_observation_matrix #calculate Sigma_e_c if not(hasattr(self,'Sigma_e_c')): t0=time.time() eta_convolution_vecrorized=pb.vectorize(self.eta.conv) eta_conv_Mu=eta_convolution_vecrorized(self.field.Mu).T Pi=pb.dot(eta_conv_Mu.T,self.field.Mu.T).astype(float).T self.Pi=Pi Sigma_e_blocks=pb.empty((1,len(self.field.NoatEachLevel)),dtype=object) Sigma_e_temp=0 #calculate (LAmbda_x )^-1* Sigma_e) for i in range(Sigma_e_blocks.shape[1]): Sigma_e_blocks_temp=Pi[Sigma_e_temp:self.field.NoatEachLevel[i]+Sigma_e_temp] Sigma_e_blocks[0,i]=pb.dot(self.Lambda_x_blocks_inverse[0,i],Sigma_e_blocks_temp) Sigma_e_temp+=self.field.NoatEachLevel[i] Sigma_e=pb.vstack(Sigma_e_blocks[0,:]) Sigma_e_temp=0 for i in range(Sigma_e_blocks.shape[1]): Sigma_e_blocks_temp=Sigma_e[:,Sigma_e_temp:self.field.NoatEachLevel[i]+Sigma_e_temp] Sigma_e_blocks[0,i]=pb.dot(Sigma_e_blocks_temp,self.Lambda_x_blocks_inverse[0,i].T) Sigma_e_temp+=self.field.NoatEachLevel[i] Sigma_e=pb.hstack(Sigma_e_blocks[0,:]) self.Sigma_e=self.eta_weight*Sigma_e print 'Elapsed time in seconds to calculate Sigma_e is',time.time()-t0 self.Sigma_e_c=sp.linalg.cholesky(self.Sigma_e,lower=1) #calculate Sigma_epsilon_c if not(hasattr(self,'Sigma_epsilon_c')): Sigma_epsilon_c=sp.linalg.cholesky(self.Sigma_epsilon,lower=1) self.Sigma_epsilon_c=Sigma_epsilon_c #calculate EM components for speed if not(hasattr(self,'Delta_upsilon')): t0=time.time() self.Delta_upsilon=dots(pb.inv(self.Sigma_e),directsum(self.Lambda_x_blocks_inverse),self.U) print 'Elapsed time in seconds to calculate Delta_upsilon is',time.time()-t0 if not(hasattr(self,'Delta_Upsilon')): t0=time.time() self.Delta_Upsilon=dots(self.U_T,directsum(self.Lambda_x_blocks_inverse),self.Delta_upsilon) print 'Elapsed time in seconds to calculate Delta_Upsilon is',time.time()-t0
print "***********************" print "some basic array math and matrix math in 2D" array1 = pylab.array([[2, 3], [4, 5]]) array2 = pylab.array([[5, 6], [3, 7]]) #このような定義でもOK vector = pylab.array([1, 2]) print "array1 is:" print array1 print "array2 is:" print array2 print "vector is:", vector print "array1 + array2:" print array1 + array2 print "array1 * array2:" print array1 * array2 print "array1 + vector:" print array1 + vector print "array1 / vector:" print array1 / vector print "pylab.dot(array1, vector)" print pylab.dot(array1, vector) array1Inv = pylab.inv(array1) print "pylab.inv(array1)" print array1Inv print "pylab.dot(array1, array1Inv)" # [[1,0], # [0,1]]になる print pylab.dot(array1, array1Inv) #pylab.crossもある
import sys sys.path.insert(0, "../../") # from SBDet import parseToCoo, gen_sigs, mix, select_model from SBDet import * import pylab as P import numpy as np # tr = zload('./EstBiase-n_num.pk') tr = zload('./EstBiase-n_num-revised.pk') n_num, iso_n, PA_para, PA_lk, ER_para, ER_lk = zip(*tr['n_num']) x = iso_n y = np.array(PA_lk).reshape(-1) - np.array(ER_lk) P.plot(x, y, 'r.') # import ipdb;ipdb.set_trace() P.axis([0, max(x), 0, max(y)]) # solve least square problem n = len(x) # X = np.hstack([np.ones((n, 1)), np.array(x).reshape(-1, 1)]) X = np.array(x).reshape(-1, 1) beta = P.dot(P.dot(P.inv(P.dot(X.T, X)), X.T), np.array(y).reshape(-1, 1)) xp = np.linspace(0, max(x), 100) yp = xp * beta[0, 0] P.plot(xp, yp, 'b--') P.xlabel('Number of isolated nodes') P.ylabel('Difference between log liklihood of PA and ER') xm = max(x) * 0.5 P.text(xm, xm * beta - 500, 'y=%f x' %(beta)) P.show()