def ws_correlation_orthoginal_distance_model(data, ref_ws_col='ref', site_ws_col='site', force_through_origin=False): """Calculate the slope and offset between two wind speed columns using orthoganal distance regression. https://docs.scipy.org/doc/scipy-0.18.1/reference/odr.html :Parameters: data: DataFrame DataFrame with wind speed columns ref and site, and direction data dir ref_ws_col: string, default None (primary anemometer assumed) Reference anemometer data to use. Extracted from MetMast.data site_ws_col: string, default None (primary anemometer assumed) Site anemometer data to use. Extracted from MetMast.data force_through_origin: boolean, default False Force the correlation through the origin (offset equal to zero) :Returns: out: DataFrame slope, offset, R2, uncert, points """ data = data.loc[:, [ref_ws_col, site_ws_col]].dropna().astype(np.float) results = return_correlation_results_frame(ref_label=ref_ws_col, site_label=site_ws_col) if not valid_ws_correlation_data(data=data, ref_ws_col=ref_ws_col, site_ws_col=site_ws_col): return results points = data.shape[0] R2 = calculate_R2(data=data, ref_ws_col=ref_ws_col, site_ws_col=site_ws_col) uncert = calculate_IEC_uncertainty(data=data, ref_ws_col=ref_ws_col, site_ws_col=site_ws_col) X = data.loc[:, ref_ws_col].values Y = data.loc[:, site_ws_col].values data_mean = data.mean() slope_estimate_via_ratio = data_mean[site_ws_col] / data_mean[ref_ws_col] realdata = odrpack.RealData(X, Y) if force_through_origin: linear = odrpack.Model(f_without_offset) odr = odrpack.ODR(realdata, linear, beta0=[slope_estimate_via_ratio]) slope = odr.run().beta[0] offset = 0 else: linear = odrpack.Model(f_with_offset) odr = odrpack.ODR(realdata, linear, beta0=[slope_estimate_via_ratio, 0.0]) slope, offset = odr.run().beta[0], odr.run().beta[1] results.loc[pd.IndexSlice[ref_ws_col, site_ws_col], ['slope', 'offset', 'R2', 'uncert', 'points']] = np.array( [slope, offset, R2, uncert, points]) return results
def poly_lsq(x, y, n, verbose=False, itmax=200): ''' Performs a polynomial least squares fit to the data, with errors! Uses scipy odrpack, but for least squares. IN: x,y (arrays) - data to fit n (int) - polinomial order verbose - can be 0,1,2 for different levels of output (False or True are the same as 0 or 1) itmax (int) - optional maximum number of iterations OUT: coeff - polynomial coefficients, lowest order first err - standard error (1-sigma) on the coefficients --Tiago, 20071114 ''' func = models.polynomial(n) mydata = odr.Data(x, y) myodr = odr.ODR(mydata, func, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() if fit.stopreason[0] == 'Iteration limit reached': print('(WWW) poly_lsq: Iteration limit reached, result not reliable!') # Results and errors coeff = fit.beta err = fit.sd_beta return coeff, err
def bilinear_Q_regression(freqs_log, Q_list_log): freqs_log = array(freqs_log) #data = odrpack.RealData(x[12:], y[12:]) data = odrpack.RealData(freqs_log, Q_list_log) #x_range = arange(-0.5, 1.0, step=0.01) # x range bilin_reg = odrpack.Model(bilinear_reg_free) odr = odrpack.ODR(data, bilin_reg, beta0=[0.4, 3.0, 0.3, -0.5]) odr.set_job( fit_type=2) #if set fit_type=2, returns the same as least squares out = odr.run() #print('\nbilinear auto\n') #out.pprint() a = out.beta[0] b = out.beta[1] c = out.beta[2] hx = out.beta[3] # x hinge point log_q_fit = b + a * freqs_log # get y values from bilinear yhinge = b + a * hx idx = freqs_log > hx log_q_fit[idx] = c * (freqs_log[idx] - hx) + yhinge return log_q_fit
def bilinear_regression(x, y): data = odrpack.RealData(x[12:], y[12:]) x_range = np.arange(-0.5, 1.0, step=0.01) # x range bilin_reg = odrpack.Model(bilinear_reg_free) odr = odrpack.ODR(data, bilin_reg, beta0=[0.4, 3.0, 0.3, -0.5]) odr.set_job(fit_type=2) #if set fit_type=2, returns the same as least squares out = odr.run() print('\nbilinear auto\n') out.pprint() a = out.beta[0] b = out.beta[1] c = out.beta[2] hx = out.beta[3] # x hinge point y_range = b + a * x_range # get y values from bilinear yhinge = b + a * hx idx = x_range > hx y_range[idx] = c * (x_range[idx]-hx) + yhinge return y_range, x_range
def gaussian_lsq(x, y, verbose=False, itmax=200, iparams=[]): ''' Performs a gaussian least squares fit to the data, with errors! Uses scipy odrpack, but for least squares.''' def _gauss_fjd(B, x): # Analytical derivative of gaussian with respect to x return 2 * (x - B[0]) * gaussian(B, x) # these derivatives need to be fixed! def _gauss_fjb(B, x): # Analytical derivatives of gaussian with respect to parameters _ret = np.concatenate( (-2 * (x - B[0]) * gaussian(B, x), ((x - B[0])**2 / (2 * B[1]**2) - 1) / B[1] * gaussian(B, x), gaussian(B, x) / B[2], np.ones(x.shape, float))) _ret.shape = (4, ) + x.shape return _ret # Centre data in mean(x) (makes better conditioned matrix) mx = np.mean(x) x2 = x - mx if not any(iparams): # automatic guessing of gaussian's initial parameters (saves # iterations) iparams = np.array([ x2[np.argmax(y)], np.std(y), math.sqrt(2 * math.pi) * np.std(y) * np.max(y), 1. ]) gauss = odr.Model(gaussian, fjacd=_gauss_fjd, fjacb=_gauss_fjb) mydata = odr.Data(x2, y) myodr = odr.ODR(mydata, gauss, beta0=iparams, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() print('Re-centered Beta: [%f %f %f %f]' % (fit.beta[0] + mx, fit.beta[1], fit.beta[2], fit.beta[3])) itlim = False if fit.stopreason[0] == 'Iteration limit reached': itlim = True print("(WWW) gauss_lsq: Iteration limit reached, result not reliable!") # Results and errors coeff = fit.beta coeff[0] += mx # Recentre in original axis err = fit.sd_beta return coeff, err, itlim
def least(func, x, y, sy=None, beta0=None, ifixb=None): linear = odrpack.Model(func) #mydata = odrpack.Data(x, z[1], wd=1./np.power(z[2],2), we=1./np.power(sy,2)) mydata = odrpack.RealData(x, y, sy=sy) myodr = odrpack.ODR(mydata, linear, beta0=beta0, ifixb=ifixb) myodr.set_job(fit_type=2) myoutput = myodr.run() # myoutput.pprint() return myodr.output
def double_gauss_lsq(x, y, verbose=False, itmax=200, iparams=[]): ''' Performs a double gaussian least squares fit to the data, with errors! Uses scipy odrpack, but for least squares.''' def _dgauss_fjd(B, x): # Analytical derivative of gaussian with respect to x return (B[0] - x) / B[1]**2 * gaussian(np.concatenate((B[:3], [0.])), x) + \ (B[3] - x) / B[4]**2 * gaussian(np.concatenate((B[3:6], [0.])), x) def _dgauss_fjb(B, x): # Analytical derivatives of gaussian with respect to parameters gauss1 = gaussian(np.concatenate((B[:3], [0.])), x) gauss2 = gaussian(np.concatenate((B[3:6], [0.])), x) _ret = np.concatenate( ((x - B[0]) / B[1]**2 * gauss1, ((B[0] - x)**2 - B[1]**2) / B[1]**3 * gauss1, gauss1 / B[2], (x - B[3]) / B[4]**2 * gauss2, ((B[3] - x)**2 - B[4]**2) / B[4]**3 * gauss2, gauss2 / B[5], np.ones(x.shape, float))) _ret.shape = (7, ) + x.shape return _ret # Centre data in mean(x) (makes better conditioned matrix) mx = mean(x) x2 = x - mx if not any(iparams): iparams = array([ x2[np.argmax(y)], np.std(y), np.sqrt(2 * np.pi) * np.std(y) * max(y), x2[np.argmax(y)], np.std(y), np.sqrt(2 * np.pi) * np.std(y) * max(y), 1. ]) dgauss = odr.Model(double_gaussian, fjacd=_dgauss_fjd, fjacb=_dgauss_fjb) mydata = odr.Data(x2, y) myodr = odr.ODR(mydata, dgauss, beta0=iparams, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() print('Re-centered Beta: [%f %f %f %f %f %f %f]' % (fit.beta[0] + mx, fit.beta[1], fit.beta[2], fit.beta[3] + mx, fit.beta[4], fit.beta[5], fit.beta[6])) itlim = False if fit.stopreason[0] == 'Iteration limit reached': itlim = True print('(WWW) gauss_lsq: Iteration limit reached, result not reliable!') # Results and errors coeff = fit.beta coeff[[0, 3]] += mx # Recentre in original axis err = fit.sd_beta return coeff, err, itlim
def fit(self, num_cuts, truncate=True, withSpreadterm=False): x, y, xaxis, m, s, cnt = CMECostModel.qc(self, num_cuts, truncate) try: popt, pcov = curve_fit(self.model_curve_guess, x, y) except RuntimeError: popt = [1.0] * CMECostModel.num_free_params func = odr.Model(self.model_curve_ODR) odrdata = odr.Data(x, y) odrmodel = odr.ODR(odrdata, func, beta0=popt, maxit=500, ifixx=[0]) o = odrmodel.run() return o, x, y, xaxis, m, s, cnt
def least(func, x, y, sy=None, beta0=[]): linear = odrpack.Model(func) #mydata = odrpack.Data(x, z[1], wd=1./np.power(z[2],2), we=1./np.power(sy,2)) if not sy == None: mydata = odrpack.RealData(x, y, sy=sy) else: mydata = odrpack.RealData(x, y) myodr = odrpack.ODR(mydata, linear, beta0=beta0, maxit=500) myodr.set_job(fit_type=2) myoutput = myodr.run() myoutput.pprint() return myodr.output
def fitScipyODR(xdata, ydata, xerr, yerr, func, pInit): """ Fit a series of data points with ODR (function must be in from f(beta[n], x)) """ model = odrpack.Model(func) data = odrpack.RealData(xdata, ydata, sx=xerr, sy=yerr) odr = odrpack.ODR(data, model, beta0=pInit) out = odr.run() popt = out.beta pcov = out.cov_beta out.pprint() print('Chi square = %f' % out.sum_square) return popt, pcov
def do_odr(f, x, xe, y, ye, estimates): model = odrpack.Model(f) # sx and sy should be the covariances data = odrpack.RealData(x, y, sx=xe, sy=ye) # need to hard-code in estimates for parameters odr = odrpack.ODR(data, model, estimates) output = odr.run() return output
def estimate_spectra(self): from scipy.odr import odrpack as odr def ofunc(pars, x, sp_sens, nu, el): a, b, dkalpha, tele = pars spectra = a * Kalpha_profile(el, nu, dkalpha) + b * ff_profile( nu, tele) spectra /= np.trapz(spectra, nu) spectra = np.tile(spectra, (sp_sens.shape[0], 1)) comp_tr = np.trapz(sp_sens * spectra, nu, axis=-1) return comp_tr def ofunc2(pars, thick, nu, el): spectra = compute_spectra(pars, nu) sp_tr_filters = np.ones(nu.shape) for filt_el, filt_thick in self.filters.iteritems(): sp_tr_filters *= np.exp(-cold_opacity(filt_el, nu=nu) * filt_thick) ip_sens = ip_sensitivity(nu) comp_tr = [] for this_thick in thick: sp_sens = np.exp(-cold_opacity(el, nu=nu)*this_thick)\ * sp_tr_filters * ip_sens * spectra comp_tr.append(np.trapz(sp_sens, nu, axis=0)) return np.array(comp_tr).reshape((1, -1)) #return ((comp_tr - exp_tr)**2).sum() beta0 = [1, 1, 100, 1000] my_data = odr.RealData(self.thick, self.exp_tr, sy=0.05 * np.ones(self.exp_tr.shape)) my_model = odr.Model(ofunc2, extra_args=(self.nu, 'polystyrene')) my_odr = odr.ODR(my_data, my_model, beta0=beta0) my_odr.set_job(fit_type=2) my_odr.set_iprint(final=2, iter=1, iter_step=1) fit = my_odr.run() self.beta = fit.beta #[::-1] self.sdbeta = fit.sd_beta #[::-1] print(ofunc2(self.beta, self.thick, self.nu, 'polystyrene')) print(self.exp_tr) print('\n') print(beta0) print(self.beta)
def fitTrack(trackArray): results = [] x = [] y = [] energy = [] for i in trackArray: x.append(i[0]) y.append(i[1]) energy.append(i[2]) slope, intercept, r_value, p_value, std_err = stats.linregress(x, y) mydata = odrpack.Data(x, y, energy, energy) linear = odrpack.Model(f) myodr = odrpack.ODR(mydata, linear, beta0=[slope, intercept]) myoutput = myodr.run() results.append(myoutput.beta) return results
def nominal_AB(self, K, N, T, explore_mag=10, res_time=100): ''' Estimates matrices A and B Args: K: The controller gain N: number of iterations to be consistent with iterative methods T: Rollout length explore_mag: noise magnitude for excitement res_time: when to reset the dynamics to its initial condition Returns: A_nom, B_nom ''' Lin_gain = LinK(K) Lin_gain.make_sampling_on(explore_mag) if T >= res_time: N = int(np.ceil(N * T / res_time)) T = res_time A_nom = np.zeros((self.n, self.n)) B_nom = np.zeros((self.n, self.m)) # storage matrices states_batch = np.zeros((self.n, N, T)) next_states_batch = np.zeros((self.n, N, T)) actions_batch = np.zeros((self.m, N, T)) # simulate for k in range(N): # Do one rollout to save data for model estimation states, actions, _, next_states = self.dyn.one_rollout(Lin_gain.sample_lin_policy, T) states_batch[:, k, :] = states.T actions_batch[:, k, :] = actions.T next_states_batch[:, k, :] = next_states.T for i in range(self.n): linear = odrpack.Model(linear_func) data = odrpack.RealData( x=np.vstack((states_batch.reshape(self.n, N * T), actions_batch.reshape(self.m, N * T))), y=next_states_batch[i, :, :].reshape(1, N * T)) Myodr = odrpack.ODR(data, linear, np.zeros(self.n + self.m)) out = Myodr.run() tmp = out.beta A_nom[i, :] = tmp[0:self.n] B_nom[i, :] = tmp[self.n:] return A_nom, B_nom
def minThis(vertex, trackArray): sumOfSquares = 0 for i in range(len(trackArray)): x = [] y = [] energy = [] #print trackArray for i in trackArray[i]: x.append(i[0]) y.append(i[1]) energy.append(i[2]) slope, intercept, r_value, p_value, std_err = stats.linregress(x, y) mydata = odrpack.Data(x, y, energy, energy) linear = odrpack.Model(fv, extra_args=vertex) myodr = odrpack.ODR(mydata, linear, beta0=[slope, intercept]) myoutput = myodr.run() sumOfSquares += myoutput.sum_square return sumOfSquares
def fitSingleCrystalBallPeak(self): params = np.array([ self.peak1_paramsEdits[0].value(), self.peak1_paramsEdits[1].value(), self.peak1_paramsEdits[2].value(), self.peak1_paramsEdits[3].value(), 0.9, 4 ]) model = odr.Model(lineshape.Single_Crystalball) odr_data = odr.RealData(self.x_cut, self.y_cut) #, sy = np.sqrt(self.y_cut)) myodr = odr.ODR(odr_data, model, beta0=params) myodr.set_job(fit_type=0) myoutput = myodr.run() self.params = myoutput.beta params_cov = myoutput.cov_beta params_output = [] params_red_chi2 = myoutput.res_var content, error = integrate.quad(lineshape.Single_Crystalball_integrand, self.x_fit[0], self.x_fit[-1], args=tuple(self.params)) params_output.append(content) params_output.append(params_red_chi2) self.params_outputs = np.array(params_output) for i in range(len(self.peak1_paramsEdits)): self.peak1_paramsEdits[i].setValue(self.params[i]) self.peak1_contentEdit.setText(str(self.params_outputs[0])) self.peak1_chi2Edit.setText(str(self.params_outputs[1])) self.plotWidget.plot(clear=True) self.plotWidget.plot(self.x, self.y[:-1], stepMode=True) fitPen = pg.mkPen(color=(204, 0, 0), width=2) self.plotWidget.plot(self.x_fit, lineshape.Single_Crystalball( self.params, self.x_fit), pen=fitPen) self.plotWidget.addItem(self.vLine, ignoreBounds=True) self.plotWidget.addItem(self.hLine, ignoreBounds=True)
def fit2(data,interval,init): interval.sort() nData = data[(data[:,0] > interval[0])&(data[:,0] < interval[1])] x=nData[:,0] y=nData[:,1] sx=None sy=None try: sx = nData[:,2] sy = nData[:,3] except: pass def func(B,x): return (1/B[0]) * x linear = odrpack.Model(func) mydata = odrpack.RealData(x, y, sx=sx, sy=sy) myodr = odrpack.ODR(mydata, linear, beta0=[init]) myoutput = myodr.run() myoutput.pprint() return [myoutput.beta[0],myoutput.sd_beta[0]]
def poly_lsq(x, y, n, verbose=False, itmax=200): """ Performs a polynomial least squares fit to the data, with errors! Uses scipy odrpack, but for least squares. Parameters ---------- x, y : 1-D arrays Data to fit. n : int Polynomial order verbose : bool or int, optional Can be 0,1,2 for different levels of output (False or True are the same as 0 or 1) itmax : int, optional Maximum number of iterations. Returns ------- coeff : 1-D array Polynomial coefficients, lowest order first. err : 1-D array Standard error (1-sigma) on the coefficients. """ func = models.polynomial(n) mydata = odr.Data(x, y) myodr = odr.ODR(mydata, func, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() if fit.stopreason[0] == 'Iteration limit reached': print('(WWW) poly_lsq: Iteration limit reached, result not reliable!') # Results and errors coeff = fit.beta err = fit.sd_beta return coeff, err
def fit_tls(x: np.ndarray, y: np.ndarray) -> float: """Fit total least squares model to data This function fits a total least squares (also known as orthogonal distance regression) model to 2-dimensional data. The model has the form `y = m * x`, where m is the "slope". (It has an intercept at y==0). See Also: At its core, the function uses scipy's `Orthogonal Distance Regression`_ module .. _Orthogonal Distance Regression: https://docs.scipy.org/doc/scipy/reference/odr.html Args: x: 1-dimensional Numpy array y: 1-dimensional Numpy array of the same size as `x` Returns: The slope of the fitted model """ odr_data = odrpack.RealData(x, y) model = odrpack.Model(lambda beta, x_: beta[0] * x_) odr_container = odrpack.ODR(odr_data, model, beta0=[1.0]) slope = odr_container.run().beta[0] #TODO PLOT SECTOR 0 some pairs (weird results) return slope
def ODRfit(model, X, Y, p0, verbose=False): if type(p0) != 'numpy.ndarray': try: p0, up0 = unpack_unarray(p0) except TypeError: pass x, ux = unpack_unarray(X) y, uy = unpack_unarray(Y) modello = odrpack.Model(model) data = odrpack.RealData(x, y, sx=ux, sy=uy) engine = odrpack.ODR(data, modello, beta0=p0) output = engine.run() P = unc.correlated_values(output.beta, output.cov_beta) if verbose: output.pprint() return P, output.sum_square
def estimate_spatial_resolution(x, y, ofunc=blurred_step_function, beta0=None, verbose=True): """ Estimate the spatial resolution of an X-ray image from a lineout of an edge. It assumes that if the spatial resolution was ideal, that should produce a sharp step. Instead we have a step convolved with a gaussian function. This function then estimates the standard deviation of this gaussian. Parameters ---------- x : ndarray : position in physical units [µm, cm, etc] y : ndarray : signal on the IP ofunc: objective function, here the convolution of a step with a gaussian beta0 : initial estimate of parameters. A good estimate could be for instance, beta0 = [y.mean(), x.mean(), 20, y.mean(), 0] verbose: true Returns ------- tuple: (std, std_err) """ from scipy import odr mmodel = odr.Model(ofunc) mdata = odr.Data(x, y) fit = odr.ODR(mdata, mmodel, beta0, maxit=1000) fit.set_job(fit_type=2) # least squares fit.set_iprint(final=verbose) fit.run() beta = fit.output.beta error = fit.output.sd_beta return beta, error
def circle_lsq(x, y, up=True, verbose=False, itmax=200, iparams=[]): ''' Method to compute a circle fit, It fits for circle parameters in the form y = B_2 +/- sqrt(B_0^2-(x-B_1)^2), the sign is negative if up is False. IN: x,y (arr) - data to fit n (int) - polinomial order verbose - can be 0,1,2 for different levels of output (False or True are the same as 0 or 1) itmax (int) - optional maximum number of iterations. iparams (arr) - optional initial parameters b0,b1,b2 OUT: coeff - polynomial coefficients, lowest order first err - standard error (1-sigma) on the coefficients --Tiago, 20080120 ''' # circle functions for B=r,x0,y0 def circle_up(B, x): return B[2] + sqrt(B[0]**2 - (x - B[1])**2) def circle_dn(B, x): return B[2] - sqrt(B[0]**2 - (x - B[1])**2) # Derivative of function in respect to x def circle_fjd_up(B, x): return -(x - B[1]) / (sqrt(B[0]**2 - (x - B[1])**2)) def circle_fjd_dn(B, x): return (x - B[1]) / (sqrt(B[0]**2 - (x - B[1])**2)) # Derivative of function in respect to B[i] def circle_fjb_up(B, x): _ret = np.concatenate(( B[0] / (sqrt(B[0]**2 - (x - B[1])**2)), -circle_fjd_up(B, x), np.ones(x.shape, float), )) _ret.shape = (3, ) + x.shape return _ret def circle_fjb_dn(B, x): _ret = np.concatenate(( B[0] / (sqrt(B[0]**2 - (x - B[1])**2)), -circle_fjd_dn(B, x), np.ones(x.shape, float), )) _ret.shape = (3, ) + x.shape return _ret if any(iparams): def circle_est(data): return tuple(iparams) else: def circle_est(data): return (1., 1., 1.) if up: circle_fit = odr.Model(circle_up, fjacd=circle_fjd_up, fjacb=circle_fjb_up, estimate=circle_est) else: circle_fit = odr.Model(circle_dn, fjacd=circle_fjd_dn, fjacb=circle_fjb_dn, estimate=circle_est) mydata = odr.Data(x, y) myodr = odr.ODR(mydata, circle_fit, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() if fit.stopreason[0] != 'Sum of squares convergence': if verbose: print('(WWW): circle_lsq: fit result not reliable') success = 0 else: success = 1 # Results and errors coeff = fit.beta err = fit.sd_beta return coeff, success, err
## Test orth. regression ## ################################################################################ def f(B, theta1): return B[0] * (np.cos((2*np.pi)/360*theta1))**2 + B[1] x = theta1 y = a1 sx = theta2 sy = a2 linear = odrpack.Model(f) myData = odrpack.RealData(x, y, sx=sx, sy=sy) myOdr = odrpack.ODR(myData, linear , beta0=[1,1]) myOdr.set_job(fit_type=2) #if set fit_type=2, returns the same as leastsq out = myOdr.run() #out.pprint() coeff = out.beta[::-1] err = out.sd_beta[::-1] print(coeff[0], err[0]) print(coeff[1], err[1]) ################################################################################ #print(np.cos(np.deg2rad(theta2))**2)
import scipy.odr.odrpack as odrpack filename1 = "LN_data.pkl" filename2 = "RT_data.pkl" dataframe1 = pd.read_pickle(filename1) dataframe2 = pd.read_pickle(filename2) currents = [0.00, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75] R_S = "Sample Resistance, R_S (Ohmns)" R_S_E = "Error in R_S, alpha_R_S (Ohms)" A = "Angle, theta (degrees)" A_E = "Error in theta, alpha_theta (degrees)" slice = dataframe1.loc[dataframe1["current"] == 0.05] x = slice[A] y = slice[R_S] sx = slice[A_E] sy = slice[R_S_E] print(x, y, sx, sy) def f(params, x): return params[0]*np.sin(params[1]*x + params[2]) + params[3] linear = odrpack.Model(f) mydata = odrpack.RealData(x, y, sx=sx, sy=sy) myodr = odrpack.ODR(mydata, linear, beta0=[0., 2., 3., 1.]) myoutput = myodr.run() myoutput.pprint() #print(myoutput.beta)
infile = sys.argv[1] outfile = sys.argv[2] dataframe = pd.read_pickle(infile) def f(params, x): rho_per, rho_par, shift = params return rho_per + (rho_par - rho_per) * np.cos(x - shift)**2 slice = dataframe.loc[dataframe.current == CURRENT] R_S = "Sample Resistance, R_S (Ohmns)" R_S_E = "Error in R_S, alpha_R_S (Ohms)" A = "Angle, theta (degrees)" A_E = "Error in theta, alpha_theta (degrees)" xs = slice[A] * np.pi / 180 ys = slice[R_S] sx = slice[A_E] * np.pi / 180 sy = slice[R_S_E] beta0 = [0., 2., 0.] linear = odrpack.Model(f) mydata = odrpack.RealData(xs, ys, sx=sx, sy=sy) myodr = odrpack.ODR(mydata, linear, beta0, maxit=100) myoutput = myodr.run() fig, ax = plt.subplots() ax.scatter(xs, ys, marker="+") ax.plot(xs, f(myoutput.beta, xs)) fig.savefig(outfile)
linear = odrpack.Model(f) #for i in range(0): mydata1 = odrpack.RealData(druck[0], brechungsindex[0], sx=Er_druck[0], sy=Er_brech[0]) mydata2 = odrpack.RealData(druck[1], brechungsindex[1], sx=Er_druck[1], sy=Er_brech[1]) mydata3 = odrpack.RealData(druck[2], brechungsindex[2], sx=Er_druck[2], sy=Er_brech[2]) myodr1 = odrpack.ODR(mydata1, linear, beta0=[1., 2.]) myodr2 = odrpack.ODR(mydata2, linear, beta0=[1., 2.]) myodr3 = odrpack.ODR(mydata3, linear, beta0=[1., 2.]) myoutput1 = myodr1.run() myoutput2 = myodr2.run() myoutput3 = myodr3.run() myoutput1.pprint() #print(myoutput1.beta[0]) linfit1 = ufloat(myoutput1.beta[0], myoutput1.sd_beta[0]) linfit2 = ufloat(myoutput2.beta[0], myoutput2.sd_beta[0]) linfit3 = ufloat(myoutput3.beta[0], myoutput3.sd_beta[0]) offset1 = myoutput1.beta[1] offset2 = myoutput2.beta[1] offset3 = myoutput3.beta[1]
# Reshape variables into a single column mag = np.reshape( mag, (-1, nt)) # Reshapes variable intro 2D matrix of voxels x timepoints ph = np.reshape(ph, (-1, nt)) stdm = np.reshape( stdm, (-1, )) # Reshapes variable intro array of length = number of voxels stdp = np.reshape(stdp, (-1, )) mask = np.reshape(mask, (-1, )) for x in range(mag.shape[0]): if mask[x]: design = ph[x, :] ests = [stdm[x] / stdp[x], 1.0] mydata = odr.RealData(design, mag[x, :], sx=stdp[x], sy=stdm[x]) odr_obj = odr.ODR(mydata, linearfit, beta0=ests, maxit=600) res = odr_obj.run() est = res.y r2[x] = 1.0 - (np.sum((mag[x, :] - est)**2) / np.sum((mag[x, :])**2)) # take out scaled phase signal and re-mean may need correction sim[x, :] = ph[x, :] * res.beta[0] filt[x, :] = mag[x, :] - est # estimate residuals residuals[x, :] = np.sign(mag[x, :] - est) * ( np.sum(res.delta**2, axis=0) + res.eps**2) delta[x, :] = np.sum( res.delta, axis=0 ) # res.delta --> Array of estimated errors in input variables (same shape as x) eps[x, :] = res.eps # res.eps --> Array of estimated errors in response variables (same shape as y)
stdbin = delete(stdbin, delidx) ''' if mb == 4.25: print(len(mmi[idx])) print(log10(rrup[idx])) print(medbin, binstrp) print(eqname[idx]) crash ''' if len(medbin < 2) and mb != 4.25: # get intercept data = odrpack.RealData(binstrp, medbin) intfit = odrpack.Model(linear_fixed_slope) odr = odrpack.ODR(data, intfit, beta0=[5.0]) #data = odrpack.RealData(10**binstrp, medbin, meta={'mag':mb}) #intfit = odrpack.Model(near_src_trunc_fixed_slope) #odr = odrpack.ODR(data, intfit, beta0=[5.0]) odr.set_job(fit_type=2) #if set fit_type=2, returns the same as leastsq, 0=ODR out = odr.run() intercept = out.beta intercepts.append(intercept[0]) meanmagbin.append(mean(mmi[idx])) meanmws.append(mean(mw[idx])) else: intercepts.append(nan) meanmagbin.append(nan) meanmws.append(nan)
def gauss_lsq(x, y, weight_x=1., weight_y=1., verbose=False, itmax=200, iparams=[]): """ Performs a Gaussian least squares fit to the data, with errors! Uses scipy odrpack, but for least squares. Parameters ---------- x : 1D array-like Observed data, independent variable y : 1D array-like Observed data, dependent variable weight_x: array-like, optional Weights for independent variable. This is typically based on the errors, if any. With errors, normal weights should be 1/err**2. If weight is a scalar, the same weight will be used for all points and therefore its value is irrelevant. weight_y: array-like, optional. Weights for independent variable. This is typically based on the errors, if any. With errors, normal weights should be 1/err**2. For Poisson weighing, should be 1/y. verbose: boolean If True, will print out more detailed information about the result. itmax: integer, Optional Maximum number of iterations, default is 200. iparams: list, optional Starting guess of Gaussian parameters. Optional but highly recommended to use realistic values! Returns ------- output: tuple Tuple with containing (coeff, err, itlim), where coeff are the fit resulting coefficients (same order as Gaussian function above), err are the errors on each coefficient, and itlim is the number of iterations. Notes ----- See documentation of scipy.odr.ordpack for more information. """ def _gauss_fjd(B, x): # Analytical derivative of gaussian with respect to x return (B[0] - x) / B[1]**2 * gaussian(np.concatenate( (B[:3], [0.])), x) def _gauss_fjb(B, x): gauss1 = gaussian(np.concatenate((B[:3], [0.])), x) # Analytical derivatives of gaussian with respect to parameters _ret = np.concatenate( ((x - B[0]) / B[1]**2 * gauss1, ((B[0] - x)**2 - B[1]**2) / B[1]**3 * gauss1, gauss1 / B[2], np.ones(x.shape, float))) _ret.shape = (4, ) + x.shape return _ret # Centre data in mean(x) (makes better conditioned matrix) mx = np.mean(x) x2 = x - mx if not any(iparams): iparams = np.array([ x2[np.argmax(y)], np.std(y), np.sqrt(2 * np.pi) * np.std(y) * max(y), 1. ]) gauss = odr.Model(gaussian, fjacd=_gauss_fjd, fjacb=_gauss_fjb) mydata = odr.Data(x2, y, wd=weight_x, we=weight_y) myodr = odr.ODR(mydata, gauss, beta0=iparams, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() print('Re-centered Beta: [%f %f %f %f]' % (fit.beta[0] + mx, fit.beta[1], fit.beta[2], fit.beta[3])) itlim = False if fit.stopreason[0] == 'Iteration limit reached': itlim = True print('(WWW) gauss_lsq: Iteration limit reached, result not reliable!') # Results and errors coeff = fit.beta coeff[0] += mx # Recentre in original axis err = fit.sd_beta return coeff, err, itlim
def quad_lsq(x, y, verbose=False, itmax=200, iparams=[]): ''' Method to compute a parabola fit, more handy as it fits for parabola parameters in the form y = B_0 * (x - B_1)**2 + B_2. This is computationally slower than poly_lsq, so beware of its usage for time consuming operations. IN: x,y (arr) - data to fit n (int) - polinomial order verbose - can be 0,1,2 for different levels of output (False or True are the same as 0 or 1) itmax (int) - optional maximum number of iterations. iparams (arr) - optional initial parameters b0,b1,b2 OUT: coeff - polynomial coefficients, lowest order first err - standard error (1-sigma) on the coefficients --Tiago, 20071115 ''' # Tiago's internal new definition of quadratic def _quadratic(B, x): return B[0] * (x - B[1]) * (x - B[1]) + B[2] def _quad_fjd(B, x): return 2 * B[0] * (x - B[1]) def _quad_fjb(B, x): _ret = np.concatenate(( np.ones(x.shape, float), 2 * B[0] * (B[1] - x), x * x - 2 * B[1] * x + B[1] * B[1], )) _ret.shape = (3, ) + x.shape return _ret if any(iparams): def _quad_est(data): return tuple(iparams) else: def _quad_est(data): return (1., 1., 1.) quadratic = odr.Model(_quadratic, fjacd=_quad_fjd, fjacb=_quad_fjb, estimate=_quad_est) mydata = odr.Data(x, y) myodr = odr.ODR(mydata, quadratic, maxit=itmax) # Set type of fit to least-squares: myodr.set_job(fit_type=2) if verbose == 2: myodr.set_iprint(final=2) fit = myodr.run() # Display results: if verbose: fit.pprint() if fit.stopreason[0] == 'Iteration limit reached': print('(WWW) quad_lsq: iteration limit reached, result not reliable!') # Results and errors coeff = fit.beta err = fit.sd_beta return coeff, err