我们从Python开源项目中，提取了以下47个代码示例，用于说明如何使用numpy.linalg.LinAlgError()。
def mahalanobis_distance(difference, num_random_features): num_samples, _ = np.shape(difference) sigma = np.cov(np.transpose(difference)) mu = np.mean(difference, 0) if num_random_features == 1: stat = float(num_samples * mu ** 2) / float(sigma) else: try: linalg.inv(sigma) except LinAlgError: print('covariance matrix is singular. Pvalue returned is 1.1') warnings.warn('covariance matrix is singular. Pvalue returned is 1.1') return 0 stat = num_samples * mu.dot(linalg.solve(sigma, np.transpose(mu))) return chi2.sf(stat, num_random_features)
def fast_optimize(endog, exog, n_obs=0, n_vars=0, max_iter=10000, tolerance=1e-10): """ A convenience function for the Newton-Raphson method to evaluate a logistic model. :param endog: An Nx1 vector of endogenous predictions :param exog: An NxK vector of exogenous predictors :param n_obs: The number of observations N :param n_vars: The number of exogenous predictors K :param max_iter: The maximum number of iterations :param tolerance: Margin of error for convergence :return: The error-minimizing parameters for the model. """ iterations = 0 oldparams = np.inf newparams = np.repeat(0, n_vars) while iterations < max_iter and np.any(np.abs(newparams - oldparams) > tolerance): oldparams = newparams try: H = logit_hessian(exog, oldparams, n_obs) newparams = oldparams - dot(inv(H), logit_score(endog, exog, oldparams, n_obs)) except LinAlgError: raise LinAlgError iterations += 1 return newparams
def solve(self, A, b): epsilon = self.epsilon force = self.force while True: try: rtn = super(InsufficientRankSolver, self).solve(A, b) break; except LinAlgError as e: if epsilon is None and force is None: raise RuntimeError("Did not provide a way to resolve sigular matrix") if epsilon is not None: diagval = np.sum(np.diagonal(A)) E = np.ones(A.shape, A.dtype)*epsilon if diagval==0: E-=np.diag(np.diag(E)) A+=E epsilon = None else: A[-1,:] = np.ones(A.shape[0], A.dtype) b[-1] = 0 force = None return rtn;
def test_0_size(self): class ArraySubclass(np.ndarray): pass # Test system of 0x0 matrices a = np.arange(8).reshape(2, 2, 2) b = np.arange(6).reshape(1, 2, 3).view(ArraySubclass) expected = linalg.solve(a, b)[:, 0:0, :] result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0, :]) assert_array_equal(result, expected) assert_(isinstance(result, ArraySubclass)) # Test errors for non-square and only b's dimension being 0 assert_raises(linalg.LinAlgError, linalg.solve, a[:, 0:0, 0:1], b) assert_raises(ValueError, linalg.solve, a, b[:, 0:0, :]) # Test broadcasting error b = np.arange(6).reshape(1, 3, 2) # broadcasting error assert_raises(ValueError, linalg.solve, a, b) assert_raises(ValueError, linalg.solve, a[0:0], b[0:0]) # Test zero "single equations" with 0x0 matrices. b = np.arange(2).reshape(1, 2).view(ArraySubclass) expected = linalg.solve(a, b)[:, 0:0] result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0]) assert_array_equal(result, expected) assert_(isinstance(result, ArraySubclass)) b = np.arange(3).reshape(1, 3) assert_raises(ValueError, linalg.solve, a, b) assert_raises(ValueError, linalg.solve, a[0:0], b[0:0]) assert_raises(ValueError, linalg.solve, a[:, 0:0, 0:0], b)
def test_invert_noninvertible(self): import numpy.linalg assert_raises(numpy.linalg.linalg.LinAlgError, lambda: matrix_power(self.noninv, -1))
def test_qr_empty(self): a = np.zeros((0, 2)) assert_raises(linalg.LinAlgError, linalg.qr, a)
def test_generalized_raise_multiloop(): # It should raise an error even if the error doesn't occur in the # last iteration of the ufunc inner loop invertible = np.array([[1, 2], [3, 4]]) non_invertible = np.array([[1, 1], [1, 1]]) x = np.zeros([4, 4, 2, 2])[1::2] x[...] = invertible x[0, 0] = non_invertible assert_raises(np.linalg.LinAlgError, np.linalg.inv, x)
def slogdet(a): """Returns sign and logarithm of the determinat of an array. It calculates the natural logarithm of the deteminant of a given value. Args: a (cupy.ndarray): The input matrix with dimension ``(..., N, N)``. Returns: tuple of :class:`~cupy.ndarray`: It returns a tuple ``(sign, logdet)``. ``sign`` represents each sign of the deteminant as a real number ``0``, ``1`` or ``-1``. 'logdet' represents the natural logarithm of the absolute of the deteminant. If the deteninant is zero, ``sign`` will be ``0`` and ``logdet`` will be ``-inf``. The shapes of both ``sign`` and ``logdet`` are equal to ``a.shape[:-2]``. .. seealso:: :func:`numpy.linalg.slogdet` """ if not cuda.cusolver_enabled: raise RuntimeError('Current cupy only supports cusolver in CUDA 8.0') if a.ndim < 2: msg = ('%d-dimensional array given. ' 'Array must be at least two-dimensional' % a.ndim) raise linalg.LinAlgError(msg) dtype = numpy.find_common_type((a.dtype.char, 'f'), ()) shape = a.shape[:-2] sign = cupy.empty(shape, dtype) logdet = cupy.empty(shape, dtype) a = a.astype(dtype) for index in numpy.ndindex(*shape): s, l = _slogdet_one(a[index]) sign[index] = s logdet[index] = l return sign, logdet
def _check_status(dev_info): status = int(dev_info) if status < 0: raise linalg.LinAlgError( 'Parameter error (maybe caused by a bug in cupy.linalg?)')
def _assert_cupy_array(*arrays): for a in arrays: if not isinstance(a, cupy.core.ndarray): raise linalg.LinAlgError( 'cupy.linalg only supports cupy.core.ndarray')
def _assert_rank2(*arrays): for a in arrays: if a.ndim != 2: raise linalg.LinAlgError( '{}-dimensional array given. Array must be ' 'two-dimensional'.format(a.ndim))
def lnprob(params, comps=None, dbf=None, phases=None, datasets=None, symbols_to_fit=None, phase_models=None, scheduler=None): """ Returns the error from multiphase fitting as a log probability. """ parameters = {param_name: param for param_name, param in zip(symbols_to_fit, params)} try: iter_error = multi_phase_fit(dbf, comps, phases, datasets, phase_models, parameters=parameters, scheduler=scheduler) except (ValueError, LinAlgError) as e: iter_error = [np.inf] iter_error = [np.inf if np.isnan(x) else x ** 2 for x in iter_error] iter_error = -np.sum(iter_error) return np.array(iter_error, dtype=np.float64)
def _eq_LinAlgError(*args, **kwargs): raise LinAlgError()
def test_lnprob_does_not_raise_on_LinAlgError(datasets_db): """lnprob() should catch LinAlgError raised by equilibrium and return -np.inf""" datasets_db.insert(zpf_json) res = lnprob([10], comps=['CU','MG', 'VA'], dbf=dbf, phases=['LIQUID', 'FCC_A1', 'HCP_A3', 'LAVES_C15', 'CUMG2'], datasets=datasets_db, symbols_to_fit=['VV0001'], phase_models=None, scheduler=None) assert np.isneginf(res)
def _estimate_bootstrapped_params(self): """ Compute the bootstrapped parameters for: * The path from the predictors to Y (computed using OLS/Logit, depending on the nature of Y) * The path(s) from the mediator(s) to Y (computed using OLS) :return: A tuple of (true_betas_y, true_betas_m) * true_betas_y is a matrix of size n_boots x n_params_y * true_betas_m is a list of matrices of size n_boots x n_params_y """ n_boots = self._options["boot"] seed = self._options["seed"] boot_betas_y = np.empty((n_boots, len(self._exog_terms_y))) boot_betas_m = np.empty((self._n_meds, n_boots, len(self._exog_terms_m))) n_fail_samples = 0 boot_ind = 0 sampler = bootstrap_sampler(self._n_obs, seed) while boot_ind < n_boots: ind = next(sampler) data_boot = self._data[ind, :] y_e = data_boot[:, self._ind_y] y_x = data_boot[:, self._exog_inds_y] try: y_b = self._compute_betas_y(y_e, y_x) m_x = data_boot[:, self._exog_inds_m] boot_betas_y[boot_ind] = y_b for j, m_ind in enumerate(self._inds_m): m_e = data_boot[:, m_ind] m_b = self._compute_betas_m(m_e, m_x) boot_betas_m[j][boot_ind] = m_b boot_ind += 1 except LinAlgError: # Hessian (Logit) or X'X (OLS) cannot be inverted n_fail_samples += 1 return boot_betas_y, boot_betas_m, n_fail_samples
def fast_OLS(endog, exog): """ A simple function for (X'X)^(-1)X'Y :return: A K-length array of estimated coefficients. """ try: return dot(dot(inv(dot(exog.T, exog)), exog.T), endog).squeeze() except LinAlgError: raise LinAlgError
def solve(a, b): """Returns the solution of A X = B.""" try: return linalg.solve(a, b) except linalg.LinAlgError: return np.dot(linalg.pinv(a), b)
def inv(a): """Returns the inverse of A.""" try: return np.linalg.inv(a) except linalg.LinAlgError: return np.linalg.pinv(a)
def is_pos_def(A): if np.array_equal(A, A.T): # Test the symmetry of the matrix. try: np.linalg.cholesky(A) # Test if it is positive definite. return True except LinAlgError: return False else: return False
def isPD(B): """Returns true when input is positive-definite, via Cholesky""" try: _ = la.cholesky(B) return True except la.LinAlgError: return False
def _fit_arima(x, xreg, order, seasonal_order, start_params, trend, method, transparams, solver, maxiter, disp, callback, fit_params, suppress_warnings, trace, error_action, out_of_sample_size, scoring, scoring_args): start = time.time() try: fit = ARIMA(order=order, seasonal_order=seasonal_order, start_params=start_params, trend=trend, method=method, transparams=transparams, solver=solver, maxiter=maxiter, disp=disp, callback=callback, suppress_warnings=suppress_warnings, out_of_sample_size=out_of_sample_size, scoring=scoring, scoring_args=scoring_args)\ .fit(x, exogenous=xreg, **fit_params) # for non-stationarity errors or singular matrices, return None except (LinAlgError, ValueError) as v: if error_action == 'warn': warnings.warn(_fmt_warning_str(order, seasonal_order)) elif error_action == 'raise': # todo: can we do something more informative in case # the error is not on the pyramid side? raise v # if it's 'ignore' or 'warn', we just return None fit = None # do trace if trace: print('Fit ARIMA: %s; AIC=%.3f, BIC=%.3f, Fit time=%.3f seconds' % (_fmt_order_info(order, seasonal_order), fit.aic() if fit is not None else np.nan, fit.bic() if fit is not None else np.nan, time.time() - start if fit is not None else np.nan)) return fit
def cholesky(a): '''Cholesky decomposition. Decompose a given two-dimensional square matrix into ``L * L.T``, where ``L`` is a lower-triangular matrix and ``.T`` is a conjugate transpose operator. Note that in the current implementation ``a`` must be a real matrix, and only float32 and float64 are supported. Args: a (cupy.ndarray): The input matrix with dimension ``(N, N)`` Returns: cupy.ndarray: The lower-triangular matrix. .. seealso:: :func:`numpy.linalg.cholesky` ''' if not cuda.cusolver_enabled: raise RuntimeError('Current cupy only supports cusolver in CUDA 8.0') # TODO(Saito): Current implementation only accepts two-dimensional arrays util._assert_cupy_array(a) util._assert_rank2(a) util._assert_nd_squareness(a) # Cast to float32 or float64 if a.dtype.char == 'f' or a.dtype.char == 'd': dtype = a.dtype.char else: dtype = numpy.find_common_type((a.dtype.char, 'f'), ()).char x = a.astype(dtype, order='C', copy=True) n = len(a) handle = device.get_cusolver_handle() dev_info = cupy.empty(1, dtype=numpy.int32) if dtype == 'f': buffersize = cusolver.spotrf_bufferSize( handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n) workspace = cupy.empty(buffersize, dtype=numpy.float32) cusolver.spotrf( handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n, workspace.data.ptr, buffersize, dev_info.data.ptr) else: # dtype == 'd' buffersize = cusolver.dpotrf_bufferSize( handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n) workspace = cupy.empty(buffersize, dtype=numpy.float64) cusolver.dpotrf( handle, cublas.CUBLAS_FILL_MODE_UPPER, n, x.data.ptr, n, workspace.data.ptr, buffersize, dev_info.data.ptr) status = int(dev_info[0]) if status > 0: raise linalg.LinAlgError( 'The leading minor of order {} ' 'is not positive definite'.format(status)) elif status < 0: raise linalg.LinAlgError( 'Parameter error (maybe caused by a bug in cupy.linalg?)') util._tril(x, k=0) return x
def cholesky(A, sparse=True): """ Choose the best possible cholesky factorizor. if possible, import the Scikit-Sparse sparse Cholesky method. Permutes the output L to ensure A = L . L.H otherwise defaults to numpy's non-sparse version Parameters ---------- A : array-like array to decompose sparse : boolean, default: True whether to return a sparse array """ if SKSPIMPORT: A = sp.sparse.csc_matrix(A) F = spcholesky(A) # permutation matrix P P = sp.sparse.lil_matrix(A.shape) p = F.P() P[np.arange(len(p)), p] = 1 # permute try: L = F.L() L = P.T.dot(L) except CholmodNotPositiveDefiniteError as e: raise NotPositiveDefiniteError('Matrix is not positive definite') if sparse: return L return L.todense() else: msg = 'Could not import Scikit-Sparse or Suite-Sparse.\n'\ 'This will slow down optimization for models with '\ 'monotonicity/convexity penalties and many splines.\n'\ 'See installation instructions for installing '\ 'Scikit-Sparse and Suite-Sparse via Conda.' warnings.warn(msg) if sp.sparse.issparse(A): A = A.todense() try: L = np.linalg.cholesky(A) except LinAlgError as e: raise NotPositiveDefiniteError('Matrix is not positive definite') if sparse: return sp.sparse.csc_matrix(L) return L
