def get_covariances(self,hyperparams): """ INPUT: hyperparams: dictionary OUTPUT: dictionary with the fields K: kernel Kinv: inverse of the kernel L: chol(K) alpha: solve(K,y) W: D*Kinv * alpha*alpha^T """ if self._is_cached(hyperparams): return self._covar_cache K = self.covar.K(hyperparams['covar']) if self.likelihood is not None: Knoise = self.likelihood.K(hyperparams['lik'],self.n) K += Knoise K[~SP.isfinite(K)] = SP.finfo(float).eps K[SP.isnan(K)] = SP.finfo(float).eps L = LA.cholesky(K).T# lower triangular alpha = LA.cho_solve((L,True),self.Y) Kinv = LA.cho_solve((L,True),SP.eye(L.shape[0])) W = self.t*Kinv - SP.dot(alpha,alpha.T) self._covar_cache = {} self._covar_cache['K'] = K self._covar_cache['Kinv'] = Kinv self._covar_cache['L'] = L self._covar_cache['alpha'] = alpha self._covar_cache['W'] = W self._covar_cache['hyperparams'] = copy.deepcopy(hyperparams) return self._covar_cache
def _update_evd(self, hyperparams, covar_id): keys = [] if 'covar_%s' % covar_id in hyperparams: keys.append('covar_%s' % covar_id) if 'X_%s' % covar_id in hyperparams: keys.append('X_%s' % covar_id) if not (self._is_cached(hyperparams, keys=keys)): K = [] S = [] U = [] i = 0 for covar in getattr(self, 'covar_%s' % covar_id): temp_kernel = covar.K(hyperparams['covar_%s' % covar_id][i]) temp_kernel = temp_kernel + SP.eye( temp_kernel.shape[0], temp_kernel.shape[1] ) * 0.001 # Rosolving possible numerical instability temp_kernel[SP.isnan(temp_kernel)] = SP.finfo(SP.float32).eps temp_kernel[~SP.isfinite(temp_kernel)] = 1E6 K.append(temp_kernel) S_temp, U_temp = LA.eigh(temp_kernel) S_temp[S_temp <= 0] = SP.finfo( SP.float32).eps # Rosolving possible numerical instability S.append(S_temp) U.append(U_temp) i += 1 self._covar_cache['K_%s' % covar_id] = K self._covar_cache['U_%s' % covar_id] = U self._covar_cache['S_%s' % covar_id] = S
def objective(pars, Z, ycovar): """The objective function""" bcost = pars[0] t = pars[1] Pb = pars[2] Xb = pars[3] Yb = pars[4] Zb = sc.array([Xb, Yb]) Vb1 = sc.exp(pars[5]) Vb2 = sc.exp(pars[6]) corr = pars[7] V = sc.array([[Vb1, sc.sqrt(Vb1 * Vb2) * corr], [sc.sqrt(Vb1 * Vb2) * corr, Vb2]]) v = sc.array([-sc.sin(t), sc.cos(t)]) if Pb < 0. or Pb > 1.: return -sc.finfo(sc.dtype(sc.float64)).max if corr < -1. or corr > 1.: return -sc.finfo(sc.dtype(sc.float64)).max delta = sc.dot(v, Z.T) - bcost sigma2 = sc.dot(v, sc.dot(ycovar, v)) ndata = Z.shape[0] detVycovar = sc.zeros(ndata) deltaOUT = sc.zeros(ndata) for ii in range(ndata): detVycovar[ii] = m.sqrt(linalg.det(V + ycovar[:, ii, :])) deltaOUT[ii] = sc.dot( Z[ii, :] - Zb, sc.dot(linalg.inv(V + ycovar[:, ii, :]), Z[ii, :] - Zb)) return sc.sum( sc.log((1. - Pb) / sc.sqrt(2. * m.pi * sigma2 / sc.cos(t)**2.) * sc.exp(-0.5 * delta**2. / sigma2) + Pb / 2. / m.pi / detVycovar * sc.exp(-0.5 * deltaOUT)))
def objective(pars,Z,ycovar): """The objective function""" bcost= pars[0] t= pars[1] Pb= pars[2] Xb= pars[3] Yb= pars[4] Zb= sc.array([Xb,Yb]) Vb1= sc.exp(pars[5]) Vb2= sc.exp(pars[6]) corr= pars[7] V= sc.array([[Vb1,sc.sqrt(Vb1*Vb2)*corr],[sc.sqrt(Vb1*Vb2)*corr,Vb2]]) v= sc.array([-sc.sin(t),sc.cos(t)]) if Pb < 0. or Pb > 1.: return -sc.finfo(sc.dtype(sc.float64)).max if corr < -1. or corr > 1.: return -sc.finfo(sc.dtype(sc.float64)).max delta= sc.dot(v,Z.T)-bcost sigma2= sc.dot(v,sc.dot(ycovar,v)) ndata= Z.shape[0] detVycovar= sc.zeros(ndata) deltaOUT= sc.zeros(ndata) for ii in range(ndata): detVycovar[ii]= m.sqrt(linalg.det(V+ycovar[:,ii,:])) deltaOUT[ii]= sc.dot(Z[ii,:]-Zb,sc.dot(linalg.inv(V+ycovar[:,ii,:]),Z[ii,:]-Zb)) return sc.sum(sc.log((1.-Pb)/sc.sqrt(2.*m.pi*sigma2)* sc.exp(-0.5*delta**2./sigma2) +Pb/2./m.pi/detVycovar *sc.exp(-0.5*deltaOUT)))
def probability_of_detection(signal_to_noise, probability_of_false_alarm, number_of_pulses, target_type): """ Calculate the probability of detection for Swerling 0 targets. :param signal_to_noise: The signal to noise ratio. :param probability_of_false_alarm: The probability of false alarm. :param number_of_pulses: The number of pulses to be non-coherently integrated. :param target_type: The Swerling target type (0, 1, 2, 3, or 4). :return: The probability of detection. """ # Calculate the threshold to noise threshold_to_noise = threshold_to_noise_ratio(probability_of_false_alarm, number_of_pulses) if target_type == 'Swerling 0': s = 0 for n in range(2, number_of_pulses + 1): s += (threshold_to_noise / (number_of_pulses * signal_to_noise)) ** (0.5 * (n - 1.0)) \ * iv(n-1, 2.0 * sqrt(number_of_pulses * signal_to_noise * threshold_to_noise)) if s == float('inf'): s = sys.float_info.max return Q(sqrt(2.0 * number_of_pulses * signal_to_noise), sqrt(2.0 * threshold_to_noise), 1e-6) \ + exp(-threshold_to_noise - number_of_pulses * signal_to_noise) * s elif target_type == 'Swerling 1': return 1.0 - gammainc(number_of_pulses - 1 + finfo(float).eps, threshold_to_noise) \ + (1.0 + 1.0 / (number_of_pulses * signal_to_noise)) ** (number_of_pulses - 1) \ * gammainc(number_of_pulses - 1 + finfo(float).eps, threshold_to_noise / (1.0 + 1.0 / (number_of_pulses * signal_to_noise))) \ * exp(-threshold_to_noise / (1.0 + number_of_pulses * signal_to_noise)) elif target_type == 'Swerling 2': return 1.0 - gammainc(number_of_pulses, threshold_to_noise / (1.0 + signal_to_noise)) elif target_type == 'Swerling 3': return (1.0 + 2.0 / (number_of_pulses * signal_to_noise)) ** (number_of_pulses - 2) * \ (1.0 + threshold_to_noise / (1.0 + 0.5 * number_of_pulses * signal_to_noise) - 2.0 * (number_of_pulses - 2.0) / (number_of_pulses * signal_to_noise)) \ * exp(-threshold_to_noise / (1.0 + 0.5 * number_of_pulses * signal_to_noise)) elif target_type == 'Swerling 4': s = 0 for k in range(number_of_pulses + 1): s += binom(number_of_pulses, k) * (0.5 * signal_to_noise) ** -k \ * gammainc(2 * number_of_pulses - k, 2 * threshold_to_noise / (signal_to_noise + 2.0)) if s == float('inf'): s = sys.float_info.max return 1.0 - (signal_to_noise / (signal_to_noise + 2.0))**number_of_pulses * s
def edge_property_vs_depth(G, property, intervals, eIndices=None, function=None): """Generic function to compile and optionally process edge information of a vascular graph versus the cortical depth. INPUT: G: Vascular graph in iGraph format. property: Which edge property to operate on. intervals: Intervals of cortical depth in which the sample is split. (Expected eIndices: (Optional.) Indices of edges to consider. If not provided, all edges are taken into account. function: (Optional.) Function which to perform on the compiled data of each interval. OUTPUT: The compiled (and possibly processed) information as a list (one entry per interval). """ intervals[-1] = (intervals[-1][0], intervals[-1][1] + sp.finfo(float).eps) database = [] for interval in intervals: if eIndices: data = G.es(eIndices, depth_ge=interval[0], depth_lt=interval[1])[property] else: data = G.es(depth_ge=interval[0], depth_lt=interval[1])[property] if function: database.append(function(data)) else: database.append(data) return database
def implant_srxtm_cube(Ga, Gd, origin=None, crWidth=150): """Implants a cubic srXTM sample in an artificial vascular network consisting of pial vessels, arterioles, venoles and capillaries. At the site of insertion, artificial vessels are removed to make space for the srXTM sample. At the border between artificial and data networks, connections are made between the respective loose ends. INPUT: Ga: VascularGraph of the artificial vasculature. Gd: VascularGraph of the srXTM data. The graph is expected to have the attributes 'av' and 'vv' that denote the indices of endpoints of the large penetrating arteries and veins respectively. origin: The two-dimensional origin in the xy plane, where the srXTM sample should be inserted. This will be the network's center of mass, if not provided. crWidth: Width of connection region. After computing the center and radius of the SRXTM sample, loose ends of the SRXTM at radius - 2*crWidth are connected to loose ends of the artificial network at radius + 2*crWidth. OUTPUT: Ga: Modified input Ga, with Gd inserted at origin. """ # Create Physiology object with appropriate default units: P = vgm.Physiology(Ga['defaultUnits']) eps = finfo(float).eps * 1e4 return Ga
def rotation_matrix_from_cross_prod(a,b): """ Returns the rotation matrix which rotates the vector :samp:`a` onto the the vector :samp:`b`. :type a: 3 sequence of :obj:`float` :param a: Vector to be rotated on to :samp:`{b}`. :type b: 3 sequence of :obj:`float` :param b: Vector. :rtype: :obj:`numpy.array` :return: 3D rotation matrix. """ crs = np.cross(a,b) dotProd = np.dot(a,b) crsNorm = sp.linalg.norm(crs) eps = sp.sqrt(sp.finfo(a.dtype).eps) r = sp.eye(a.size, a.size, dtype=a.dtype) if (crsNorm > eps): theta = sp.arctan2(crsNorm, dotProd) r = axis_angle_to_rotation_matrix(crs, theta) elif (dotProd < 0): r = -r return r
def edge_property_vs_depth(G,property,intervals,eIndices=None,function=None): """Generic function to compile and optionally process edge information of a vascular graph versus the cortical depth. INPUT: G: Vascular graph in iGraph format. property: Which edge property to operate on. intervals: Intervals of cortical depth in which the sample is split. (Expected eIndices: (Optional.) Indices of edges to consider. If not provided, all edges are taken into account. function: (Optional.) Function which to perform on the compiled data of each interval. OUTPUT: The compiled (and possibly processed) information as a list (one entry per interval). """ intervals[-1] = (intervals[-1][0], intervals[-1][1] + sp.finfo(float).eps) database = [] for interval in intervals: if eIndices: data = G.es(eIndices,depth_ge=interval[0], depth_lt=interval[1])[property] else: data = G.es(depth_ge=interval[0], depth_lt=interval[1])[property] if function: database.append(function(data)) else: database.append(data) return database
def pre_compute_E_Beta(x, y, sig, kernel="RBF"): """ Function that pre computes the kernel eigenvalues/eigenfunctions during the cross-validation Input: x,y: the sample matrix and the label sig: the value of the kernel parameters Output: E_: a list of eigenvalues Beta_: a list of corresponding eigenvectors """ C = int(y.max()) eps = sp.finfo(sp.float64).eps E_ = [] Beta_ = [] for i in range(C): t = sp.where(y == (i + 1))[0] ni = t.size Ki = KERNEL() Ki.compute_kernel(x[t, :], kernel=kernel, sig=sig) Ki.center_kernel() Ki.scale_kernel(ni) E, Beta = linalg.eigh(Ki.K) idx = E.argsort()[::-1] E = E[idx] E[E < eps] = eps Beta = Beta[:, idx] E_.append(E) Beta_.append(Beta) del E, Beta, Ki return E_, Beta_
def directivity(frequency, length, current): """ The directivity of a finite length dipole antenna. :param frequency: The operating frequency (Hz). :param length: The length of the dipole (m). :param current: The peak current on the dipole (A). :return: The directivity of a small dipole antenna. """ # Calculate the wave impedance eta = sqrt(mu_0 / epsilon_0) # Calculate the wave number times the length kl = 2.0 * pi * frequency / c * length # Calculate the radiation intensity factor factor = eta * abs(current)**2 / (8.0 * pi**2) # Calculate the power radiated power_radiated = radiated_power(frequency, length, current) # Calculate the maximum of the radiation intensity theta = linspace(finfo(float).eps, 2.0 * pi, 10000) u_max = max(((cos(0.5 * kl * cos(theta)) - cos(0.5 * kl)) / sin(theta))**2) return 4.0 * pi * factor * u_max / power_radiated
def rotation_matrix_from_cross_prod(a, b): """ Returns the rotation matrix which rotates the vector :samp:`a` onto the the vector :samp:`b`. :type a: 3 sequence of :obj:`float` :param a: Vector to be rotated on to :samp:`{b}`. :type b: 3 sequence of :obj:`float` :param b: Vector. :rtype: :obj:`numpy.array` :return: 3D rotation matrix. """ crs = np.cross(a, b) dotProd = np.dot(a, b) crsNorm = sp.linalg.norm(crs) eps = sp.sqrt(sp.finfo(a.dtype).eps) r = sp.eye(a.size, a.size, dtype=a.dtype) if (crsNorm > eps): theta = sp.arctan2(crsNorm, dotProd) r = axis_angle_to_rotation_matrix(crs, theta) elif (dotProd < 0): r = -r return r
def pre_compute_E_Beta(x, y, sig, kernel='RBF'): ''' Function that pre computes the kernel eigenvalues/eigenfunctions during the cross-validation Input: x,y: the sample matrix and the label sig: the value of the kernel parameters Output: E_: a list of eigenvalues Beta_: a list of corresponding eigenvectors ''' C = int(y.max()) eps = sp.finfo(sp.float64).eps E_ = [] Beta_ = [] for i in range(C): t = sp.where(y == (i + 1))[0] ni = t.size Ki = KERNEL() Ki.compute_kernel(x[t, :], kernel=kernel, sig=sig) Ki.center_kernel() Ki.scale_kernel(ni) E, Beta = linalg.eigh(Ki.K) idx = E.argsort()[::-1] E = E[idx] E[E < eps] = eps Beta = Beta[:, idx] E_.append(E) Beta_.append(Beta) del E, Beta, Ki return E_, Beta_
def zexpmv(A, v, t, norm_est=1., m=5, tol=0., trace=False, A_is_Herm=False): assert A.dtype.type is sp.complex128 assert v.dtype.type is sp.complex128 #Override expokit deault precision to match scipy sparse eigs more closely. if tol == 0: tol = sp.finfo( sp.complex128 ).eps * 2 #cannot take eps, as expokit changes this to sqrt(eps)! xn = A.shape[0] vf = sp.ones((xn, ), dtype=A.dtype) m = min(xn - 1, m) nwsp = max(10, xn * (m + 2) + 5 * (m + 2)**2 + ideg + 1) wsp = sp.zeros((nwsp, ), dtype=A.dtype) niwsp = max(7, m + 2) iwsp = sp.zeros((niwsp, ), dtype=sp.int32) iflag = sp.zeros((1, ), dtype=sp.int32) itrace = sp.array([int(trace)]) if A_is_Herm: expokit.zhexpv(m, [t], v, vf, [tol], [norm_est], wsp, iwsp, A.matvec, itrace, iflag, n=[xn], lwsp=[len(wsp)], liwsp=[len(iwsp)]) else: expokit.zgexpv(m, [t], v, vf, [tol], [norm_est], wsp, iwsp, A.matvec, itrace, iflag, n=[xn], lwsp=[len(wsp)], liwsp=[len(iwsp)]) if iflag[0] == 1: print "Max steps reached!" elif iflag[0] == 2: print "Tolerance too high!" elif iflag[0] < 0: print "Bad arguments!" elif iflag[0] > 0: print "Unknown error!" return vf
def train(self, x, y, mu=None, sig=None): # Initialization n = y.shape[0] C = int(y.max()) eps = sp.finfo(sp.float64).eps if (mu is None) and (self.mu is None): mu = 10**(-7) elif self.mu is None: self.mu = mu if (sig is None) and (self.sig is None): self.sig = 0.5 elif self.sig is None: self.sig = sig # Compute K and K = KERNEL() K.compute_kernel(x, sig=self.sig) G = KERNEL() G.K = self.mu * sp.eye(n) for i in range(C): t = sp.where(y == (i + 1))[0] self.ni.append(sp.size(t)) self.prop.append(float(self.ni[i]) / n) # Compute K_k Ki = KERNEL() Ki.compute_kernel(x, z=x[t, :], sig=self.sig) T = (sp.eye(self.ni[i]) - sp.ones((self.ni[i], self.ni[i]))) Ki.K = sp.dot(Ki.K, T) del T G.K += sp.dot(Ki.K, Ki.K.T) / self.ni[i] G.scale_kernel(C) # Solve the generalized eigenvalue problem a, A = linalg.eigh(G.K, b=K.K) idx = a.argsort()[::-1] a = a[idx] A = A[:, idx] # Remove negative eigenvalue t = sp.where(a > eps)[0] a = a[t] A = A[:, t] # Normalize the eigenvalue for i in range(a.size): A[:, i] /= sp.sqrt(sp.dot(sp.dot(A[:, i].T, K.K), A[:, i])) # Update model self.a = a.copy() self.A = A.copy() self.S = sp.dot(sp.dot(self.A, sp.diag(self.a**(-1))), self.A.T) # Free memory del G, K, a, A
def train(self, x, y, mu=None, sig=None): # Initialization n = y.shape[0] C = int(y.max()) eps = sp.finfo(sp.float64).eps if (mu is None) and (self.mu is None): mu = 10 ** (-7) elif self.mu is None: self.mu = mu if (sig is None) and (self.sig is None): self.sig = 0.5 elif self.sig is None: self.sig = sig # Compute K and K = KERNEL() K.compute_kernel(x, sig=self.sig) G = KERNEL() G.K = self.mu * sp.eye(n) for i in range(C): t = sp.where(y == (i + 1))[0] self.ni.append(sp.size(t)) self.prop.append(float(self.ni[i]) / n) # Compute K_k Ki = KERNEL() Ki.compute_kernel(x, z=x[t, :], sig=self.sig) T = sp.eye(self.ni[i]) - sp.ones((self.ni[i], self.ni[i])) Ki.K = sp.dot(Ki.K, T) del T G.K += sp.dot(Ki.K, Ki.K.T) / self.ni[i] G.scale_kernel(C) # Solve the generalized eigenvalue problem a, A = linalg.eigh(G.K, b=K.K) idx = a.argsort()[::-1] a = a[idx] A = A[:, idx] # Remove negative eigenvalue t = sp.where(a > eps)[0] a = a[t] A = A[:, t] # Normalize the eigenvalue for i in range(a.size): A[:, i] /= sp.sqrt(sp.dot(sp.dot(A[:, i].T, K.K), A[:, i])) # Update model self.a = a.copy() self.A = A.copy() self.S = sp.dot(sp.dot(self.A, sp.diag(self.a ** (-1))), self.A.T) # Free memory del G, K, a, A
def _update_canvas(self): """ Update the figure when the user changes an input value :return: """ # Get the parameters from the form frequency = float(self.frequency.text()) number_of_elements = int(self.number_of_elements.text()) scan_angle = float(self.scan_angle.text()) element_spacing = float(self.element_spacing.text()) side_lobe_level = float(self.side_lobe_level.text()) # Get the selected antenna from the form antenna_type = self.antenna_type.currentText() # Set the angular span theta = linspace(0.0, pi, 1000) # Set up the args kwargs = { 'number_of_elements': number_of_elements, 'scan_angle': radians(scan_angle), 'element_spacing': element_spacing, 'frequency': frequency, 'theta': theta, 'window_type': antenna_type, 'side_lobe_level': side_lobe_level } # Get the array factor af = linear_array.array_factor(**kwargs) # Clear the axes for the updated plot self.axes1.clear() # Create the line plot self.axes1.plot(degrees(theta), 20.0 * log10(abs(af) + finfo(float).eps), '') # Set the y axis limit self.axes1.set_ylim(-80, 5) # Set the x and y axis labels self.axes1.set_xlabel("Theta (degrees)", size=12) self.axes1.set_ylabel("Array Factor (dB)", size=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Set the plot title and labels self.axes1.set_title('Linear Array Antenna Pattern', size=14) # Set the tick label size self.axes1.tick_params(labelsize=12) # Update the canvas self.my_canvas.draw()
def predict(self, xt, tau=None, confidenceMap=None): ''' Function that predict the label for sample xt using the learned model Inputs: xt: the samples to be classified Outputs: y: the class K: the decision value for each class ''' MAX = sp.finfo(sp.float64).max E_MAX = sp.log( MAX) # Maximum value that is possible to compute with sp.exp ## Get information from the data nt = xt.shape[0] # Number of testing samples C = self.ni.shape[0] # Number of classes ## Initialization K = sp.empty((nt, C)) if tau is None: TAU = self.tau else: TAU = tau for c in range(C): invCov, logdet = self.compute_inverse_logdet(c, TAU) cst = logdet - 2 * sp.log(self.prop[c]) # Pre compute the constant xtc = xt - self.mean[c, :] temp = sp.dot(invCov, xtc.T).T K[:, c] = sp.sum(xtc * temp, axis=1) + cst del temp, xtc yp = sp.argmin(K, 1) if confidenceMap is None: ## Assign the label save in classnum to the minimum value of K yp = self.classnum[yp] return yp else: K *= -0.5 K[K > E_MAX], K[K < -E_MAX] = E_MAX, -E_MAX sp.exp(K, out=K) K /= K.sum(axis=1).reshape(nt, 1) K = K[sp.arange(len(K)), yp] #K = sp.diag(K[:,yp]) yp = self.classnum[yp] return yp, K
def objective(pars,X,Y,yerr): """The objective function""" b= pars[0] s= pars[1] Pb= pars[2] Yb= pars[3] Vb= m.exp(pars[4]) if Pb < 0. or Pb > 1.: return -sc.finfo(sc.dtype(sc.float64)).max return sc.sum(sc.log((1.-Pb)/sc.sqrt(2.*m.pi)/yerr*sc.exp(-0.5*(Y-s*X-b)**2./yerr**2.)+Pb/sc.sqrt(2.*m.pi*(Vb+yerr**2.))*sc.exp(-0.5*(Y-Yb)**2./(Vb+yerr**2.))))#+pars[4]
def __init__(self, module, dataset, totalIterations = 100, xPrecision = finfo(float).eps, fPrecision = finfo(float).eps, init_scg=True, **kwargs): """Create a SCGTrainer to train the specified `module` on the specified `dataset`. """ Trainer.__init__(self, module) self.setData(dataset) self.input_sequences = self.ds.getField('input') self.epoch = 0 self.totalepochs = 0 self.module = module #self.tmp_module = module.copy() if init_scg: self.scg = SCG(self.module.params, self.f, self.df, self, totalIterations, xPrecision, fPrecision, evalFunc = lambda x: str(x / self.ds.getLength())) else: print "Warning: SCG trainer not initialized!"
def __init__(self, N, uni_ground): self.odr = 'C' self.typ = sp.complex128 self.zero_tol = sp.finfo(self.typ).resolution """Tolerance for detecting zeros. This is used when (pseudo-) inverting l and r.""" self._sanity_checks = False self.N = N """The number of sites. Do not change after initializing.""" self.N_centre = N / 2 """The 'centre' site. This affects the gauge-fixing and canonical form. It is the site between the left-gauge parts and the right-gauge parts.""" self.D = sp.repeat(uni_ground.D, self.N + 2) """Vector containing the bond-dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.q = sp.repeat(uni_ground.q, self.N + 2) """Vector containing the site Hilbert space dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.S_hc = sp.repeat(sp.NaN, self.N + 1) """Vector containing the von Neumann entropy S_hc[n] corresponding to splitting the state between sites n and n + 1. Available only after performing update(restore_CF=True) or restore_CF().""" self.uni_l = copy.deepcopy(uni_ground) self.uni_l.symm_gauge = False self.uni_l.sanity_checks = self.sanity_checks self.uni_l.update() self.uni_r = copy.deepcopy(uni_ground) self.uni_r.sanity_checks = self.sanity_checks self.uni_r.symm_gauge = False self.uni_r.update() self.grown_left = 0 self.grown_right = 0 self.shrunk_left = 0 self.shrunk_right = 0 self._init_arrays() for n in xrange(self.N + 2): self.A[n][:] = self.uni_l.A self.r[self.N] = self.uni_r.r self.r[self.N + 1] = self.r[self.N] self.l[0] = self.uni_l.l
def fspecial_gaussian(hsize, sigma): hsize = [hsize, hsize] siz = [(hsize[0]-1.0)/2.0, (hsize[1]-1.0)/2.0] std = sigma [x, y] = np.meshgrid(np.arange(-siz[1], siz[1]+1), np.arange(-siz[0], siz[0]+1)) arg = -(x*x + y*y)/(2*std*std) h = np.exp(arg) h[h < scipy.finfo(float).eps * h.max()] = 0 sumh = h.sum() if sumh != 0: h = h/sumh return h
def test_numpy_deprecation_functionality(): # Check that the deprecation wrappers don't break basic NumPy # functionality with deprecated_call(): x = scipy.array([1, 2, 3], dtype=scipy.float64) assert x.dtype == scipy.float64 assert x.dtype == np.float64 x = scipy.finfo(scipy.float32) assert x.eps == np.finfo(np.float32).eps assert scipy.float64 == np.float64 assert issubclass(np.float64, scipy.float64)
def __init__(self, N, uni_ground): self.odr = 'C' self.typ = sp.complex128 self.zero_tol = sp.finfo(self.typ).resolution """Tolerance for detecting zeros. This is used when (pseudo-) inverting l and r.""" self._sanity_checks = False self.N = N """The number of sites. Do not change after initializing.""" self.N_centre = N / 2 """The 'centre' site. This affects the gauge-fixing and canonical form. It is the site between the left-gauge parts and the right-gauge parts.""" self.D = sp.repeat(uni_ground.D, self.N + 2) """Vector containing the bond-dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.q = sp.repeat(uni_ground.q, self.N + 2) """Vector containing the site Hilbert space dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.uni_l = copy.deepcopy(uni_ground) self.uni_l.symm_gauge = True self.uni_l.sanity_checks = self.sanity_checks self.uni_l.update() if not N % self.uni_l.L == 0: print "Warning: Length of nonuniform window is not a multiple of the uniform block size." self.uni_r = copy.deepcopy(self.uni_l) self.grown_left = 0 self.grown_right = 0 self.shrunk_left = 0 self.shrunk_right = 0 self._init_arrays() for n in xrange(1, self.N + 1): self.A[n][:] = self.uni_l.A[(n - 1) % self.uni_l.L] for n in xrange(self.N + 2): self.r[n][:] = sp.asarray(self.uni_l.r[(n - 1) % self.uni_l.L]) self.l[n][:] = sp.asarray(self.uni_l.l[(n - 1) % self.uni_l.L])
def __init__(self, N, uni_ground): self.odr = 'C' self.typ = sp.complex128 self.zero_tol = sp.finfo(self.typ).resolution """Tolerance for detecting zeros. This is used when (pseudo-) inverting l and r.""" self._sanity_checks = False self.N = N """The number of sites. Do not change after initializing.""" self.N_centre = N // 2 """The 'centre' site. This affects the gauge-fixing and canonical form. It is the site between the left-gauge parts and the right-gauge parts.""" self.D = sp.repeat(uni_ground.D, self.N + 2) """Vector containing the bond-dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.q = sp.repeat(uni_ground.q, self.N + 2) """Vector containing the site Hilbert space dimensions. A[n] is a q[n] x D[n - 1] x D[n] tensor.""" self.uni_l = copy.deepcopy(uni_ground) self.uni_l.symm_gauge = True self.uni_l.sanity_checks = self.sanity_checks self.uni_l.update() if not N % self.uni_l.L == 0: print("Warning: Length of nonuniform window is not a multiple of the uniform block size.") self.uni_r = copy.deepcopy(self.uni_l) self.grown_left = 0 self.grown_right = 0 self.shrunk_left = 0 self.shrunk_right = 0 self._init_arrays() for n in range(1, self.N + 1): self.A[n][:] = self.uni_l.A[(n - 1) % self.uni_l.L] for n in range(self.N + 2): self.r[n][:] = sp.asarray(self.uni_l.r[(n - 1) % self.uni_l.L]) self.l[n][:] = sp.asarray(self.uni_l.l[(n - 1) % self.uni_l.L])
def evaluate_hull(x, hull): """evaluate_hull: evaluate h_u(x) and (optional) h_l(x) Input: x - abcissa hull - the hull (see setup_hull for a definition) Output: hu(x) (optional), hl(x) History: 2009-05-21 - Written - Bovy (NYU) """ #Find in which [z_{i-1},z_i] interval x lies if x < hull[4][0]: #x lies in the first interval hux = hull[3][0] * (x - hull[1][0]) + hull[2][0] indx = 0 else: if len(hull[5]) == 1: #There are only two intervals indx = 1 else: indx = 1 while indx < len(hull[4]) and hull[4][indx] < x: indx = indx + 1 indx = indx - 1 hux = hull[3][indx] * (x - hull[1][indx]) + hull[2][indx] #Now evaluate hlx neginf = sc.finfo(sc.dtype(sc.float64)).min if x < hull[1][0] or x > hull[1][-1]: hlx = neginf else: if indx == 0: hlx = ((hull[1][1] - x) * hull[2][0] + (x - hull[1][0]) * hull[2][1]) / (hull[1][1] - hull[1][0]) elif indx == len(hull[4]): hlx = ( (hull[1][-1] - x) * hull[2][-2] + (x - hull[1][-2]) * hull[2][-1]) / (hull[1][-1] - hull[1][-2]) elif x < hull[1][indx + 1]: hlx = ((hull[1][indx + 1] - x) * hull[2][indx] + (x - hull[1][indx]) * hull[2][indx + 1]) / ( hull[1][indx + 1] - hull[1][indx]) else: hlx = ((hull[1][indx + 2] - x) * hull[2][indx + 1] + (x - hull[1][indx + 1]) * hull[2][indx + 2]) / ( hull[1][indx + 2] - hull[1][indx + 1]) return hux, hlx
def billard_setup_strip(self, R1, R2, d, N): # d = increment of radius # N = number of balls for the unit circle rads = sp.linspace(R1, R2, (R2-R1)/d) pts = [] for r in rads: num = r * N base = sp.linspace(0, (2-sp.finfo(float).eps)*sp.pi, num) # split up the circumference to num pieces for arg in base: x = r*(sp.cos(arg)) y = r*(sp.sin(arg)) pts.append((x,y)) self.balls = sp.array(pts) self.corner_slopes()
def compute_E(PI): """Compute the entropy from soft assignment of the pixels to each cluster of the object. Input: -PI (array): belongship probability of each pixel (row) to each cluster (columns) Return: -E (float): entropy """ E= 0 ni,nC = PI.shape #Nbr of pixels in the object, number of clusters for c in range(nC): #For each cluster PI_c = 1./ni * sp.sum(PI[:,c]) #Average belongship probability of the obejct to this cluster if PI_c > sp.finfo(sp.float64).eps: E += - PI_c * sp.log(PI_c) return E
def safe_logdet(cov): ''' The function computes a secure version of the logdet of a covariance matrix and it returns the rcondition number of the matrix. Inputs: cov Outputs: the logdet ''' eps = sp.finfo(sp.float64).eps e = linalg.eigvalsh(cov) if e.max() < eps: rcond = 0 else: rcond = e.min() / e.max() e = sp.where(e < eps, eps, e) return sp.sum(sp.log(e)), rcond
def safe_logdet(cov): ''' The function computes a secure version of the logdet of a covariance matrix and it returns the rcondition number of the matrix. Inputs: cov Outputs: the logdet ''' eps = sp.finfo(sp.float64).eps e = linalg.eigvalsh(cov) if e.max()<eps: rcond = 0 else: rcond = e.min()/e.max() e = sp.where(e<eps,eps,e) return sp.sum(sp.log(e)),rcond
def __init__(self, numsites, uni_ground): self.u_gnd_l = uni.EvoMPS_TDVP_Uniform(uni_ground.D, uni_ground.q) self.u_gnd_l.sanity_checks = self.sanity_checks self.u_gnd_l.h_nn = uni_ground.h_nn self.u_gnd_l.h_nn_cptr = uni_ground.h_nn_cptr self.u_gnd_l.A = uni_ground.A.copy() self.u_gnd_l.l = uni_ground.l.copy() self.u_gnd_l.r = uni_ground.r.copy() self.u_gnd_l.symm_gauge = False self.u_gnd_l.update() self.u_gnd_l.calc_lr() self.u_gnd_l.calc_B() self.eta_uni = self.u_gnd_l.eta self.u_gnd_l_kmr = la.norm(self.u_gnd_l.r / la.norm(self.u_gnd_l.r) - self.u_gnd_l.K / la.norm(self.u_gnd_l.K)) self.u_gnd_r = uni.EvoMPS_TDVP_Uniform(uni_ground.D, uni_ground.q) self.u_gnd_r.sanity_checks = self.sanity_checks self.u_gnd_r.symm_gauge = False self.u_gnd_r.h_nn = uni_ground.h_nn self.u_gnd_r.h_nn_cptr = uni_ground.h_nn_cptr self.u_gnd_r.A = self.u_gnd_l.A.copy() self.u_gnd_r.l = self.u_gnd_l.l.copy() self.u_gnd_r.r = self.u_gnd_l.r.copy() self.grown_left = 0 self.grown_right = 0 self.shrunk_left = 0 self.shrunk_right = 0 self.h_nn = self.wrap_h self.h_nn_mat = None self.eps = sp.finfo(self.typ).eps self.N = numsites self._init_arrays() for n in xrange(self.N + 2): self.A[n][:] = self.u_gnd_l.A self.r[self.N] = self.u_gnd_r.r self.r[self.N + 1] = self.r[self.N] self.l[0] = self.u_gnd_l.l
def learn(self, x, y): ''' Function that learns the GMM with ridge regularizationb from training samples Input: x : the training samples y : the labels Output: the mean, covariance and proportion of each class, as well as the spectral decomposition of the covariance matrix ''' ## Get information from the data C = sp.unique(y).shape[0] #C = int(y.max(0)) # Number of classes n = x.shape[0] # Number of samples d = x.shape[1] # Number of variables eps = sp.finfo(sp.float64).eps ## Initialization self.ni = sp.empty( (C, 1)) # Vector of number of samples for each class self.prop = sp.empty((C, 1)) # Vector of proportion self.mean = sp.empty((C, d)) # Vector of means self.cov = sp.empty((C, d, d)) # Matrix of covariance self.Q = sp.empty((C, d, d)) # Matrix of eigenvectors self.L = sp.empty((C, d)) # Vector of eigenvalues self.classnum = sp.empty(C).astype('uint8') ## Learn the parameter of the model for each class for c, cR in enumerate(sp.unique(y)): j = sp.where(y == (cR))[0] self.classnum[c] = cR # Save the right label self.ni[c] = float(j.size) self.prop[c] = self.ni[c] / n self.mean[c, :] = sp.mean(x[j, :], axis=0) self.cov[c, :, :] = sp.cov( x[j, :], bias=1, rowvar=0 ) # Normalize by ni to be consistent with the update formulae # Spectral decomposition L, Q = linalg.eigh(self.cov[c, :, :]) idx = L.argsort()[::-1] self.L[c, :] = L[idx] self.Q[c, :, :] = Q[:, idx]
def create_delta_vec(parvec, scales): ''' Make parameter delta vector suitable for numerical differentiation (NR 5.7 -- equation 5.7.8 -- optimal delta choice for centered differentiation) input: parameter vector (copied) default scale vector - used where parameter==0 -- obviously no scales[i] should be zero!! ''' deltavec = sp.copy(parvec) # where equal to zero, set to scales - deltavec[parvec == 0.] = scales[parvec == 0.] npars = deltavec.size machine_resolution = (sp.finfo(deltavec.dtype)).resolution # trickery to get exactly machine representable delta: for i in range(npars): h = (machine_resolution)**(1.0 / 3.0) * deltavec[i] temp = deltavec[i] + h do_nothing_with(temp) deltavec[i] = temp - deltavec[i] return deltavec
def learn(self,x,y): ''' Function that learns the GMM with ridge regularizationb from training samples Input: x : the training samples y : the labels Output: the mean, covariance and proportion of each class, as well as the spectral decomposition of the covariance matrix ''' ## Get information from the data C = sp.unique(y).shape[0] #C = int(y.max(0)) # Number of classes n = x.shape[0] # Number of samples d = x.shape[1] # Number of variables eps = sp.finfo(sp.float64).eps ## Initialization self.ni = sp.empty((C,1)) # Vector of number of samples for each class self.prop = sp.empty((C,1)) # Vector of proportion self.mean = sp.empty((C,d)) # Vector of means self.cov = sp.empty((C,d,d)) # Matrix of covariance self.Q = sp.empty((C,d,d)) # Matrix of eigenvectors self.L = sp.empty((C,d)) # Vector of eigenvalues self.classnum = sp.empty(C).astype('uint8') ## Learn the parameter of the model for each class for c,cR in enumerate(sp.unique(y)): j = sp.where(y==(cR))[0] self.classnum[c] = cR # Save the right label self.ni[c] = float(j.size) self.prop[c] = self.ni[c]/n self.mean[c,:] = sp.mean(x[j,:],axis=0) self.cov[c,:,:] = sp.cov(x[j,:],bias=1,rowvar=0) # Normalize by ni to be consistent with the update formulae # Spectral decomposition L,Q = linalg.eigh(self.cov[c,:,:]) idx = L.argsort()[::-1] self.L[c,:] = L[idx] self.Q[c,:,:]=Q[:,idx]
def evaluate_hull(x,hull): """evaluate_hull: evaluate h_u(x) and (optional) h_l(x) Input: x - abcissa hull - the hull (see setup_hull for a definition) Output: hu(x) (optional), hl(x) History: 2009-05-21 - Written - Bovy (NYU) """ #Find in which [z_{i-1},z_i] interval x lies if x < hull[4][0]: #x lies in the first interval hux= hull[3][0]*(x-hull[1][0])+hull[2][0] indx= 0 else: if len(hull[5]) == 1: #There are only two intervals indx= 1 else: indx= 1 while indx < len(hull[4]) and hull[4][indx] < x: indx= indx+1 indx= indx-1 hux= hull[3][indx]*(x-hull[1][indx])+hull[2][indx] #Now evaluate hlx neginf= sc.finfo(sc.dtype(sc.float64)).min if x < hull[1][0] or x > hull[1][-1]: hlx= neginf else: if indx == 0: hlx= ((hull[1][1]-x)*hull[2][0]+(x-hull[1][0])*hull[2][1])/(hull[1][1]-hull[1][0]) elif indx == len(hull[4]): hlx= ((hull[1][-1]-x)*hull[2][-2]+(x-hull[1][-2])*hull[2][-1])/(hull[1][-1]-hull[1][-2]) elif x < hull[1][indx+1]: hlx= ((hull[1][indx+1]-x)*hull[2][indx]+(x-hull[1][indx])*hull[2][indx+1])/(hull[1][indx+1]-hull[1][indx]) else: hlx= ((hull[1][indx+2]-x)*hull[2][indx+1]+(x-hull[1][indx+1])*hull[2][indx+2])/(hull[1][indx+2]-hull[1][indx+1]) return hux, hlx
def orthonormal(m): """ calculate eigen vectors of a random symmetric m by m matrix and fetch its eigenvectors verify it it is orthonormal, recurse it tests fail :param m: :return: """ A = sp.rand(m, m) S = A * A.T _, P = linalg.eigh(S) # verification I = sp.eye(m) tolerance = sp.finfo(float).eps * 16 if (P.dot(P.T) - I > tolerance).any(): return orthonormal(m) return P
def zexpmv(A, v, t, norm_est=1., m=5, tol=0., trace=False, A_is_Herm=False): assert A.dtype.type is sp.complex128 assert v.dtype.type is sp.complex128 #Override expokit deault precision to match scipy sparse eigs more closely. if tol == 0: tol = sp.finfo(sp.complex128).eps * 2 #cannot take eps, as expokit changes this to sqrt(eps)! xn = A.shape[0] vf = sp.ones((xn,), dtype=A.dtype) m = min(xn - 1, m) nwsp = max(10, xn * (m + 2) + 5 * (m + 2)**2 + ideg + 1) wsp = sp.zeros((nwsp,), dtype=A.dtype) niwsp = max(7, m + 2) iwsp = sp.zeros((niwsp,), dtype=sp.int32) iflag = sp.zeros((1,), dtype=sp.int32) itrace = sp.array([int(trace)]) if A_is_Herm: expokit.zhexpv(m, [t], v, vf, [tol], [norm_est], wsp, iwsp, A.matvec, itrace, iflag, n=[xn], lwsp=[len(wsp)], liwsp=[len(iwsp)]) else: expokit.zgexpv(m, [t], v, vf, [tol], [norm_est], wsp, iwsp, A.matvec, itrace, iflag, n=[xn], lwsp=[len(wsp)], liwsp=[len(iwsp)]) if iflag[0] == 1: print "Max steps reached!" elif iflag[0] == 2: print "Tolerance too high!" elif iflag[0] < 0: print "Bad arguments!" elif iflag[0] > 0: print "Unknown error!" return vf
def mylstsq(a, b, rcond): ''' Compute a safe/fast least square fitting. For that particular case, the number of unknown parameters is equal to the number of equations. However, a is a covariance matrix that might estimated with a number of samples less than the number of variables, leading to a badly conditionned covariance matrix. So, the rcond number is check: if it is ok, we use the fast linalg.solve function; otherwise, we use the slow, but safe, linalg.lstsq function. Inputs: a: a symmetric definite positive matrix d times d b: a d times n matrix Outputs: x: a d times n matrix ''' eps = sp.finfo(sp.float64).eps if rcond>eps: # If the condition number is not too bad try linear system try: x = linalg.solve(a,b) except linalg.LinAlgError: # If error, use least square estimations x = linalg.lstsq(a,b)[0] else:# Use least square estimate x = linalg.lstsq(a,b)[0] return x
def beamwidth(frequency, length): """ The half power beamwidth of a finite length dipole antenna. :param frequency: The operating frequency (Hz). :param length: The length of the dipole (m). :return: The half power beamwidth of a small dipole antenna (deg). """ # Calculate the wavenumber times the length kl = 2.0 * pi * frequency / c * length # Calculate the normalized radiation intensity theta = linspace(finfo(float).eps, 2.0 * pi, 10000) f = ((cos(0.5 * kl * cos(theta)) - cos(0.5 * kl)) / sin(theta))**2 g = f / max(f) for iT, iU in zip(theta, g): if iU >= 0.5: theta_half = 0.5 * pi - iT break return 2.0 * theta_half * 180.0 / pi
def beamwidth(frequency, radius): """ The half power beamwidth of a circular loop antenna. :param frequency: The operating frequency (Hz). :param radius: The radius of the circular loop (m). :return: The beamwidth (deg). """ # Calculate the wavenumber k = 2.0 * pi * frequency / c # Calculate the normalized radiation intensity theta = linspace(finfo(float).eps, 2.0 * pi, 10000) f = (j1(k * radius * sin(theta)))**2 g = f / max(f) for iT, iU in zip(theta, g): if iU >= 0.5: theta_half = 0.5 * pi - iT break return 2.0 * theta_half * 180.0 / pi
def mylstsq(a, b, rcond): ''' Compute a safe/fast least square fitting. For that particular case, the number of unknown parameters is equal to the number of equations. However, a is a covariance matrix that might estimated with a number of samples less than the number of variables, leading to a badly conditionned covariance matrix. So, the rcond number is check: if it is ok, we use the fast linalg.solve function; otherwise, we use the slow, but safe, linalg.lstsq function. Inputs: a: a symmetric definite positive matrix d times d b: a d times n matrix Outputs: x: a d times n matrix ''' eps = sp.finfo(sp.float64).eps if rcond > eps: # If the condition number is not too bad try linear system try: x = linalg.solve(a, b) except linalg.LinAlgError: # If error, use least square estimations x = linalg.lstsq(a, b)[0] else: # Use least square estimate x = linalg.lstsq(a, b)[0] return x
def fixpoint(f, x, tol=None, maxit=100, **kwargs): """ Fixed point function iteration Parameters ------------- f : function Function for which to find the fixed point. x : array Initial guess. tol : float, optional Tolerance for convergence. maxit : int, optional Maximum number of iterations. Returns ----------- info : integer Did function converge? -1 if it did not, and 0 if it did. relres : float Relative residual at last iteration. t : int Number of iterations gval : array Fixed point, where f(x) = x. """ if tol is None: tol = sqrt(sp.finfo(float).eps) info = -1 t = 0 for it in range(maxit): t += 1 gval = f(x, **kwargs) relres = la.norm(gval - x) if relres < tol: info = 0 break x = gval return (info, relres, t, gval)
def newton(self, y, t=1, tol=None, maxit=100, verbose=False): """ Newton iteration Parameters ------------ y : ndarray, shape (155, ) Initial parameter guess. Changed in place. tol : float Tolerance for convergence maxit : int Maximum number of iterations verbose : bool Whether to print messages during iterations Returns ------- info: integer Did function converge? True if it did. relres : float Relative residual of last iteration i : int Number of iterations """ if tol is None: tol = sp.sqrt(sp.finfo(float).eps) info = False for i in range(maxit): f, df, dft = self.func(y, t) dy = la.solve(df, f) y -= dy relres = la.norm(dy) if verbose: print("%d: %f" % (i, relres)) if relres < tol: info = True break return (info, relres, i)
def predict(self, xt, x, y, out_decision=None, out_proba=None): nt = xt.shape[0] C = int(y.max()) D = sp.empty((nt, C)) D += self.prop eps = sp.finfo(sp.float64).eps # Pre compute the Gramm kernel matrix Kt = KERNEL() Kt.compute_kernel(xt, z=x, sig=self.sig) Ki = KERNEL() for i in range(C): t = sp.where(y == (i + 1))[0] Ki.compute_kernel(x, z=x[t, :], sig=self.sig) T = Kt.K - sp.dot(Ki.K, sp.ones((self.ni[i])) / self.ni[i]) temp = sp.dot(T, self.S) D[:, i] = sp.sum(T * temp, axis=1) # Check if negative value if D.min() < 0: D -= D.min() yp = D.argmin(1) + 1 yp.shape = (nt, 1) # Format the output if out_proba is None: if out_decision is None: return yp else: return yp, D else: # Compute posterior !! Should be changed to a safe version P = sp.exp(-0.5 * D) P /= sp.sum(P, axis=1).reshape(nt, 1) P[P < eps] = 0 return yp, D, P
def area(pts): from scipy.spatial import ConvexHull # Get the area of convex hull enclosing points (2D) # check if collinear tfcollinear = True eps = sp.finfo(float).eps for kk in range(2, len(pts)): if( pts[0][0] * (pts[1][1] - pts[kk][1]) + pts[1][0] * (pts[kk][1] - pts[0][1]) + pts[kk][0] * (pts[0][1] - pts[1][1]) > eps): tfcollinear = False break # calculate convex hull of pts if tfcollinear: area = 0 else: hull = ConvexHull(pts) area = hull.volume return area
def decomposition(self, M): """ Compute the decompostion of symmetric matrix Inputs: M: matrix to decompose Outputs: vp: eigenvalues Q: eigenvectors rcond: conditioning """ # Decomposition vp,Q = linalg.eigh(M) # Compute conditioning eps = sp.finfo(sp.float64).eps if vp.max()<eps: rcond = 0 else: rcond = vp.min()/vp.max() vp[vp<eps] = eps return vp,Q,rcond
def axis_angle_from_rotation_matrix(rm): """ Converts 3x3 rotation matrix to axis and angle representation. :type rm: 3x3 :obj:`float` matrix :param rm: Rotation matrix. :rtype: :obj:`tuple` :return: :samp:`(axis, radian_angle)` pair (angle in radians). """ eps = (16*sp.finfo(rm.dtype).eps) aa = sp.array((0,0,1), dtype=rm.dtype) theta = aa[0]; c = (sp.trace(rm) - 1)/2; if (c > 1): c = 1; if (c < -1): c = -1; if (math.fabs(math.fabs(c)-1) >= eps): theta = math.acos(c); s = math.sqrt(1-c*c); inv2s = 1/(2*s); aa[0] = inv2s*(rm[2,1] - rm[1,2]); aa[1] = inv2s*(rm[0,2] - rm[2,0]); aa[2] = inv2s*(rm[1,0] - rm[0,1]); elif (c >= 0): theta = 0; else: rmI = (rm + sp.eye(3,3,dtype=rm.dtype)); theta = np.pi; for i in range(0,3): n2 = np.linalg.norm(rmI[:,i]); if (n2 > 0): aa = col(rmI, i); break; return aa, theta
def __init__(self, N, uni_ground): super(EvoMPS_TDVP_Sandwich, self).__init__(N, uni_ground) assert uni_ground.ham_sites == 2, 'Sandwiches only supported for \ nearest-neighbour Hamiltonians at present!' self.uni_l.calc_B() self.eta_sq_uni = self.uni_l.eta_sq print("Bulk eta: ", self.eta_sq_uni) self.h_nn = None """The Hamiltonian for the nonuniform region. Can be changed, for example, to perform a quench or to study an impurity problem. The number of neighbouring sites acted on must be specified in ham_sites.""" if callable(self.uni_l.ham): self.h_nn = lambda n, s, t, u, v: self.uni_l.ham(s, t, u, v) else: self.h_nn = [self.uni_l.ham] * (self.N + 1) self.eps = sp.finfo(self.typ).eps
def d2c(sys,method='zoh'): """Continous to discrete conversion with ZOH method Call: sysc=c2d(sys,method='log') Parameters ---------- sys : System in statespace or Tf form method: 'zoh' or 'bi' Returns ------- sysc: continous system ss or tf """ flag = 0 if isinstance(sys, TransferFunction): sys=tf2ss(sys) flag=1 a=sys.A b=sys.B c=sys.C d=sys.D Ts=sys.Tsamp n=shape(a)[0] nb=shape(b)[1] nc=shape(c)[0] tol=1e-12 if method=='zoh': if n==1: if b[0,0]==1: A=0 B=b/sys.Tsamp C=c D=d else: tmp1=hstack((a,b)) tmp2=hstack((zeros((nb,n)),eye(nb))) tmp=vstack((tmp1,tmp2)) s=logm(tmp) s=s/Ts if norm(imag(s),inf) > sqrt(sp.finfo(float).eps): print "Warning: accuracy may be poor" s=real(s) A=s[0:n,0:n] B=s[0:n,n:n+nb] C=c D=d elif method=='bi': a=mat(a) b=mat(b) c=mat(c) d=mat(d) poles=eigvals(a) if any(abs(poles-1)<200*sp.finfo(float).eps): print "d2c: some poles very close to one. May get bad results." I=mat(eye(n,n)) tk = 2 / sqrt (Ts) A = (2/Ts)*(a-I)*inv(a+I) iab = inv(I+a)*b B = tk*iab C = tk*(c*inv(I+a)) D = d- (c*iab) else: print "Method not supported" return sysc=ss(A,B,C,D) if flag==1: sysc=ss2tf(sysc) return sysc
def __call__(self, X, evalfunc, maxEpoch=100, verbose=False, convergenceThreshold=None): """ Run the scaled conjugate gradient descent """ eps = finfo(float).eps sigma0 = 1.0e-4 epoch = 0 # Initial function value and gradient fold, gradnew = evalfunc(X) fnew = fold gradold = gradnew.copy() # Initial search direction d = -gradnew.copy() # Force calculation of ddirectional derivs success = True # nsuccess counts number of successes nsuccess = 0 # Initial scale parameter beta = 1.0 theta = 0.0 # Lower and upper bound on scale betamin = 1.0e-15 betamax = 1.0e100 # Set the convergence threshold deltaThreshold = 1.0e-8 ratioThreshold = 1.0e-6 if convergenceThreshold is not None: deltaThreshold = convergenceThreshold[0] ratioThreshold = convergenceThreshold[1] pass # Main optimization loop epoch = 1 while epoch < maxEpoch: # Calculate first and second directional derivatives if success: mu = dot(d, gradnew) if mu >= 0: d = -gradnew.copy() mu = dot(d, gradnew) pass kappa = dot(d, d) if kappa < eps: print("kappa: ", kappa, " eps: ", eps) print("Terminated due to kappa < eps.") return pass sigma = sigma0 / sqrt(kappa) Xplus = X.copy() Xplus.params[:] = X.params + sigma * d _, gplus = evalfunc(Xplus) theta = dot(d, gplus - gradnew) / sigma pass # Increase effective curvature and evaluate step size alpha delta = theta + beta * kappa if delta <= 0: delta = beta * kappa beta = beta - theta / kappa pass alpha = -mu/delta # Calculate the comparison ratio Xnew = X.copy() Xnew.params[:] = X.params + alpha * d fnew, _ = evalfunc(Xnew) Delta = 2.0 * (fnew - fold) / (alpha * mu) if Delta >= 0.0: success = True nsuccess += 1 X = Xnew.copy() fnow = fnew else: success = False fnow = fold pass if verbose: print("Epoch {:d} Error {:f} Scale {:f}".format(epoch, fnow, beta)) if success: # Test for termination if absolute(alpha * d).max() < ratioThreshold: if absolute(fnew - fold) < deltaThreshold: return pass else: # Update variables for new position fold = fnew gradold = gradnew.copy() _, gradnew = evalfunc(X) # If the gradient is zero, then we are done. if dot(gradnew, gradnew) == 0: print("Optimization converges. Final error: ", fnew) return pass pass pass # Adjust beta according to comparison ratio if Delta < 0.25: beta = min(4.0 * beta, betamax) pass if Delta > 0.75: beta = max(0.5 * beta, betamin) pass # Update search direction using Polack-Ribiere formula, or restart # in direction of negative gradient after nparams steps if nsuccess == X.params.shape[0]: d = -gradnew.copy() nsuccess = 0 else: if success: gamma = dot(gradold - gradnew, gradnew) / mu d = dot(gamma, d) - gradnew pass pass epoch += 1 pass # If we get here, then we haven't terminated in the given number of # iterations. print("Warning: Maximum number of iterations has been exceeded")
""" Taken from sklearn.gaussian_process module and stripped out naked to the bare minimum """ from scipy import linalg as LA import scipy as sp from sklearn.utils import array2d from sklearn.gaussian_process import correlation_models import Cholesky MACHINE_EPSILON = sp.finfo(sp.double).eps def kernel(d, theta, correlation='squared_exponential'): if correlation is 'absolute_exponential': return sp.exp(-d / theta) # correlation_models.absolute_exponential(theta, d) elif correlation is 'squared_exponential': return sp.exp(-d**2 / (2.0 * theta**2)) # correlation_models.squared_exponential(theta, d) elif correlation is 'generalized_exponential': return correlation_models.generalized_exponential(theta, d) elif correlation is 'cubic': return correlation_models.cubic(theta, d) elif correlation is 'linear': return correlation_models.linear(theta, d) else: print "Correlation model %s not understood" % correlation return None def matrix_distance(A, B):
squeeze, tile, reshape, \ ones, zeros, int_, \ setxor1d, sort, union1d, unique, \ finfo from scipy.linalg import svd import numpy as num # module variables sqr6i = 1./sqrt(6.) sqr3i = 1./sqrt(3.) sqr2i = 1./sqrt(2.) sqr2 = sqrt(2.) sqr3 = sqrt(3.) sqr2b3 = sqrt(2./3.) fpTol = finfo(float).eps # ~2.2e-16 vTol = 1.0e-14 def columnNorm(a): """ normalize array of column vectors (hstacked, axis = 0) """ if len(a.shape) > 2: raise RuntimeError, "incorrect shape: arg must be 1-d or 2-d, yours is %d" %(len(a.shape)) cnrma = sqrt(sum(asarray(a)**2, 0)) return cnrma def rowNorm(a):
"""noise generation with multivariate autoregressive models""" __docformat__ = "restructuredtext" ##---IMPORTS # packages import scipy as N from scipy import linalg as NL, random as NR from collections import deque from noise_gen import NoiseGen ##---CONSTANTS EPS = N.finfo(N.float64).eps ##---FUNCTIONS def ar_fit(p_data, p_or_plist=range(100), selector='sbc'): """fits a (multivariate) AR (_A_uto_R_egrssive) model to data :Parameters: p_data : ndarray Data with observations on the rows and variables on the columns p_or_plist : list List of model orders to select from. This list has to be continuous with a step size of 1, e.g. [10,11,12,13,14] selector : str One of 'sbc' for the Schwarz Bayesian Criterion or 'fpe' for the
def __init__(self, numsites, D, q): """Creates a new TDVP_MPS object. The TDVP_MPS class implements the time-dependent variational principle for matrix product states for systems with open boundary conditions and a hamiltonian consisting of a nearest-neighbour interaction term and a single-site term (external field). Bond dimensions will be adjusted where they are too high to be useful. FIXME: Add reference. Parameters ---------- numsites : int The number of lattice sites. D : ndarray A 1-d array, length numsites, of integers indicating the desired bond dimensions. q : ndarray A 1-d array, also length numsites, of integers indicating the dimension of the hilbert space for each site. Returns ------- sqrt_A : ndarray An array of the same shape and type as A containing the matrix square root of A. """ self.eps = sp.finfo(self.typ).eps self.N = numsites self.D = sp.array(D) self.q = sp.array(q) #Make indicies correspond to the thesis self.K = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N self.C = sp.empty((self.N), dtype=sp.ndarray) #Elements 1..N-1 self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N self.l = sp.empty((self.N + 1), dtype=sp.ndarray) if (self.D.ndim != 1) or (self.q.ndim != 1): raise NameError('D and q must be 1-dimensional!') #TODO: Check for integer type. #Don't do anything pointless self.D[0] = 1 self.D[self.N] = 1 qacc = 1 for n in reversed(xrange(self.N)): if qacc < self.D.max(): #Avoid overflow! qacc *= self.q[n + 1] if self.D[n] > qacc: self.D[n] = qacc qacc = 1 for n in xrange(1, self.N + 1): if qacc < self.D.max(): #Avoid overflow! qacc *= q[n - 1] if self.D[n] > qacc: self.D[n] = qacc self.r[0] = sp.zeros((self.D[0], self.D[0]), dtype=self.typ, order=self.odr) self.l[0] = sp.eye(self.D[0], self.D[0], dtype=self.typ).copy(order=self.odr) #Already set the 0th element (not a dummy) for n in xrange(1, self.N + 1): self.K[n] = sp.zeros((self.D[n-1], self.D[n-1]), dtype=self.typ, order=self.odr) self.r[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr) self.l[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr) self.A[n] = sp.empty((self.q[n], self.D[n-1], self.D[n]), dtype=self.typ, order=self.odr) if n < self.N: self.C[n] = sp.empty((self.q[n], self.q[n+1], self.D[n-1], self.D[n+1]), dtype=self.typ, order=self.odr) sp.fill_diagonal(self.r[self.N], 1.) self.setup_A() self.eta = sp.zeros((self.N + 1), dtype=self.typ)
def take_step_implicit(self, dtau, midpoint=True): """A backward (implicit) integration step. Based on p. 8-10 of arXiv:1103.0936v2 [cond-mat.str-el]. NOTE: Not currently working as well as expected. Iterative solution of implicit equation stops converging at some point... This is made trickier by the gauge freedom. We solve the implicit equation iteratively, aligning the tangent vectors along the gauge orbits for each step to obtain the physically relevant difference dA. The gauge-alignment is done by solving a matrix equation. The iteration seems to be difficult. At the moment, iteration over the whole chain is combined with iteration over a single site (a single A[n]). Iteration over the chain is needed because the evolution of a single site depends on the state of the whole chain. The algorithm runs through the chain from N to 1, iterating a few times over each site (depending on how many chain iterations we have done, since iterating over a single site becomes more fruitful as the rest of the chain stabilizes). In running_update mode, which is likely the most sensible choice, the current midpoint guess is updated after visiting each site. I.e. The trial backwards step at site n is based on the updates that were made to site n + 1, n + 2 during the current chain iteration. Parameters ---------- dtau : complex The (imaginary or real) amount of imaginary time (tau) to step. midpoint : bool Whether to use approximately time-symmetric midpoint integration, or just a backward-Euler step. """ #--------------------------- #Hard-coded params: debug = True dbg_bstep = False safe_mode = True tol = sp.finfo(sp.complex128).eps * 3 max_iter = 10 itr_switch_mode = 10 #--------------------------- if midpoint: dtau = dtau / 2 self.restore_RCF() #Take a copy of the current state A0 = sp.empty_like(self.A) for n in xrange(1, self.N + 1): A0[n] = self.A[n].copy() #Take initial forward-Euler step self.take_step(dtau) itr = 0 delta = 1 delta_prev = 0 final_check = False while delta > tol * (self.N - 1) and itr < max_iter or final_check: print "OUTER" running_update = itr < itr_switch_mode A_np1 = A0[self.N] #Prepare for next calculation of B from the new A self.restore_RCF() #updates l and r if running_update: self.calc_C() #we really do need all of these, since B directly uses C[n-1] self.calc_K() g0_n = sp.eye(self.D[self.N - 1], dtype=self.typ) #g0_n is the gauge transform matrix needed to solve the implicit equation #Loop through the chain, optimizing the individual A's delta = 0 for n in reversed(xrange(1, self.N)): #We start at N - 1, since the right vector can't be altered here. print "SWEEP" if not running_update: #save new A[n + 1] and replace with old version for building B A_np1_new = self.A[n + 1].copy() self.A[n + 1] = A_np1 A_np1 = self.A[n].copy() max_itr_n = 1 #wait until the next run-through of the chain to change A[n] again else: max_itr_n = itr + 1 #do more iterations here as the outer loop progresses delta_n = 1 itr_n = 0 while True: print "INNER" #Find transformation to gauge-align A0 with the backwards-obtained A.. is this enough? M = m.mmul(A0[n][0], g0_n, self.r[n], m.H(self.A[n][0])) for s in xrange(1, self.q[n]): M += m.mmul(A0[n][s], g0_n, self.r[n], m.H(self.A[n][s])) g0_nm1 = la.solve(self.r[n - 1], M, sym_pos=True, overwrite_b=True) if not (delta_n > tol and itr_n < max_itr_n): break B = self.calc_B(n) if B is None: delta_n = 0 fnorm = 0 break g0_nm1_inv = la.inv(g0_nm1) #sadly, we need the inverse too... r_dA = sp.zeros_like(self.r[n - 1]) dA = sp.empty_like(self.A[n]) sqsum = 0 for s in xrange(self.q[n]): dA[s] = m.mmul(g0_nm1_inv, A0[n][s], g0_n) dA[s] -= self.A[n][s] dA[s] -= dtau * B[s] if not final_check: self.A[n][s] += dA[s] for s in xrange(self.q[n]): r_dA += m.mmul(dA[s], self.r[n], m.H(dA[s])) sqsum += sum(dA[s]**2) fnorm = sp.sqrt(sqsum) delta_n = sp.sqrt(sp.trace(m.mmul(self.l[n - 1], r_dA))) if running_update: #Since we want to use the current A[n] and A[n + 1], we need this: if safe_mode: self.restore_RCF() self.calc_C() self.calc_K() else: self.restore_RCF(start=n) #will also renormalize self.calc_C(n_low=n-1, n_high=n) self.calc_K(n_low=n, n_high=n+1) itr_n += 1 if final_check: break if not running_update: #save new A[n + 1] and replace with old version for building B self.A[n + 1] = A_np1_new if debug: print "delta_%d: %g, (%d iterations)" % (n, delta_n.real, itr_n) + ", fnorm = " + str(fnorm) delta += delta_n if safe_mode: self.calc_r() else: self.calc_r(n - 2, n - 1) #We only need these for the next step. g0_n = g0_nm1 itr += 1 if debug: print "delta: %g delta delta: %g (%d iterations)" % (delta.real, (delta - delta_prev).real, itr) delta_prev = delta if debug: if final_check: break elif delta <= tol * (self.N - 1) or itr >= max_iter: print "Final check to get final delta:" final_check = True #Test backward step! if dbg_bstep: Anew = sp.empty_like(self.A) for n in xrange(1, self.N + 1): Anew[n] = self.A[n].copy() # self.calc_l() # self.simple_renorm() # self.restore_RCF() self.calc_C() self.calc_K() self.take_step(-dtau) self.restore_RCF() delta2 = 0 for n in reversed(xrange(1, self.N + 1)): #print n dA = A0[n] - self.A[n] #Surely this dA should also preserve the gauge choice, since both A's are in ON_R... #print dA/A0[n] r_dA = sp.zeros_like(self.r[n - 1]) sqsum = 0 for s in xrange(self.q[n]): r_dA += m.mmul(dA[s], self.r[n], m.H(dA[s])) sqsum += sum(dA[s]**2) delta_n = sp.sqrt(sp.trace(m.mmul(self.l[n - 1], r_dA))) delta2 += delta_n if debug: print "A[%d] OK?: " % n + str(sp.allclose(dA, 0)) + ", delta = " + str(delta_n) + ", fnorm = " + str(sp.sqrt(sqsum)) #print delta_n if debug: print "Total delta: " + str(delta2) for n in xrange(1, self.N + 1): self.A[n] = Anew[n] else: delta2 = 0 if midpoint: #Take a final step from the midpoint #self.restore_RCF() #updates l and r self.calc_l() self.simple_renorm() self.calc_C() self.calc_K() self.take_step(dtau) return itr, delta, delta2