def _fit_odr(self): # # Fitting function # def fcn(params, x): for i in xrange(len(params)): if abs(params[i]) == nan or abs(params[i]) == inf: params[i] = self.model.x0[i]()['value'] return [1e100]*len(x) if params[i] < self.model.x0[i]()['min']: params[i] = self.model.x0[i]()['min'] return [1e100]*len(x) if params[i] > self.model.x0[i]()['max']: params[i] = self.model.x0[i]()['max'] return [1e100]*len(x) return self.model.fcn(params, x, self.model.const) # # create Model # model = odr.Model(fcn) # # Get a list with the fitting start parameters and create the # ODR fitting object self.solver = odr.ODR(self.data, model, beta0=self.model.params, ifixb=self.model.froozen, maxit=self.maxfev) self.solver.set_job(fit_type=self.fitType-1) # # Run the fitting ... # output = self.solver.run() # # If result is not satisfying (output.info > 4) run fitting again # if(output.info >= 4): self.solver = odr.ODR(self.data, model, beta0=output.beta, ifixb=self.model.froozen, maxit=self.maxfev) self.solver.set_job(fit_type=self.fitType-1, restart=0) output = self.solver.run() if(output.info >= 4): if self.verbose: ('ODRPACK still unable to find solution: \n%s\n\t\t' %(output.stopreason) ) for i in xrange(self.model.get_paramCount()): if not self.model.froozen[i]: self.model.params[i] = output.beta[i] self.storeResult(output) return self.result
def fit(self): ''' Description ----------- Standard fit with or without errors Parameters ----------- Returns ----------- θ: array parameters σ: array standard deviations Σ: array covariance matrix ''' # Fitting usemod = odr.Model( lambda θ, x: modeling.__dict__[self.model](θ, x, *self.add).fit(), lambda θ, x: modeling.__dict__[self.model] (θ, x, *self.add).jacobian()) #usemod = eval('odr.Model(self.'+self.model+'_fit, extra_args=self.add)') dats = odr.RealData(self.x, self.y, sx=self.xerr, sy=self.yerr) r = odr.ODR(dats, usemod, self.init).run() # Outputting self.θ = r.beta self.σ = r.sd_beta self.Σ = r.cov_beta self.r = r return self.θ, self.σ, self.Σ
def gauss_fit_ba(datax, datay, errory, beta0=[0, 1, 1, 0, 0]): mod = sdr.Model(gaussian_ba) dat = sdr.RealData(datax, datay, sy=errory) odr = sdr.ODR(dat, mod, beta0=beta0) odr.set_job(fit_type=2) res = odr.run() return [res.beta, res.sd_beta, res.res_var]
def autoCorrelation(xData): maxTp = 400 xMean = np.average(xData) C = np.zeros(maxTp) tPr = np.zeros(maxTp) for i in xrange(maxTp): xLen = xData.shape[0] runTot = 0 for j in xrange(xLen - i): runTot += xData[j] * xData[j + i] C[i] = (float(runTot) / float(xLen - i)) tPr[i] = (i) C = C - xMean**2. lnC = np.log(C) myodr = odr.ODR(odr.Data(tPr, lnC), odr.Model(str8Line), beta0=[-0.00558, -1.0]) result = myodr.run() fitLine = result.beta[0] * tPr + result.beta[1] pl.plot(tPr, lnC) pl.plot(tPr, fitLine) pl.show() correlationTime = -1.0 / result.beta[0] print correlationTime return correlationTime
def autoCorrelation(xData,maxRange): """ A function to calculate the auto correlation time of a data set. :xData: the data for which the time is found. :maxRange: the range over which an exponential decay is fitted(=100). """ maxTp = maxRange # the maximum distance between values in a list, eg List[0] and List[100] xMean = np.average(xData) # finds the mean of all values C = np.zeros(maxTp) # numpy arrays to hold Correlation tPr = np.zeros(maxTp) # different Correlation times, t', No of elements between values for i in xrange(maxTp): xLen = xData.shape[0] runTot = 0 for j in xrange(xLen-i): runTot+=xData[j]*xData[j+i] # checks how correlated each bit is C[i]=(float(runTot)/float(xLen-i)) tPr[i]=(i) C = C - xMean**2. lnC = np.log(C) myodr = odr.ODR(odr.Data(tPr,lnC), odr.Model(str8Line), beta0=[-1.0, -1.0]) result = myodr.run() fitLine = result.beta[0]*tPr + result.beta[1] #pl.plot(tPr,lnC) #pl.plot(tPr,fitLine) #pl.show() correlationTime = -1.0/result.beta[0] if np.isnan(correlationTime):return 700 return correlationTime
def ODR_Linear_Fit(X, dX, Y, dY): if len(X) != len(Y): raise Exception("The vectors are not the same length! ") if len(X) < 3: raise Exception("Use at least 3 points! ") dX = np.array([dX]) dY = np.array([dY]) N = len(X) if len(dX) == 1: dX = dX * np.ones(N) if len(dY) == 1: dY = dY * np.ones(N) linear = odr.Model(ODR_Linear_Fit_f) mydata = odr.RealData(X, y=Y, sx=dX, sy=dY) myodr = odr.ODR(mydata, linear, beta0=[1, 2]) myoutput = myodr.run() myoutput.pprint() m = myoutput.beta[0] b = myoutput.beta[1] sm = myoutput.sd_beta[0] sb = myoutput.sd_beta[1] rchi2 = myoutput.res_var dof = len(myoutput.beta) chi2 = rchi2 * dof P = 1 - scichi.cdf(chi2, dof) return m, sm, b, sb, rchi2, P
def fitLine(data): start = 0 end = 0 rest = 0 listOfSpeeds = [] errors = [] frameNo = [] metEnd = False for i in xrange(len(data) - 1): rest += 1 frameNo.append(i) if data[i + 1] < data[i] and metEnd == False: start = i + 9 metEnd = True if data[i + 1] > data[i] and rest > 10: metEnd = False rest = 0 end = i x = frameNo[start:end] y = data[start:end] myodr = odr.ODR(odr.Data(frameNo[start:end], data[start:end]), odr.Model(str8Line), beta0=[-0.5, 70]) result = myodr.run() fitLine = result.beta[0] * frameNo[start:end] + result.beta[1] listOfSpeeds.append(result.beta[0]) errors.append(result.sd_beta[0]) return np.mean(listOfSpeeds), np.mean(errors)
def __init__(self, list_of_points, pointcloud): self.points = list_of_points model = odr.Model(odr_linear_definition) #extract coordinates from list of points x = [pointcloud.points[p][0] for p in list_of_points] y = [pointcloud.points[p][1] for p in list_of_points] #calculate standard errors along dimensions or something wd = 1/(np.std(x)**2) #FIXME: I have no idea what this is we = 1/(np.std(y)**2) #or if I did it right #fit ODR data = odr.Data(x, y, wd=wd, we=we) self.odr = odr.ODR(data, model, beta0=[1., 1.]) self.odr.run() params = self.odr.output.beta #apply bounds for start and end point bounds = [] for index in [-1, 0]: m, b = params p_x, p_y = pointcloud.points[self.points[index]] bounds.append(self._find_closest_input_val(m, b, p_x, p_y)) bounds.sort() #save the params in nice formats params = {"m": params[0], "b": params[1], "low": bounds[0], "high": bounds[1]} self.params = params self.start_point = [params["low"], params["low"] * params["m"] + params["b"]] self.end_point = [params["high"], params["high"] * params["m"] + params["b"]]
def perform_odr(x, y, sx, sy): linear = odr.Model(f) mydata = odr.Data(x, y, wd=1./np.power(sx,2), we=1./np.power(sy,2)) myodr = odr.ODR(mydata, linear, beta0=linreg[0:2]) output = myodr.run() output.pprint() return output
def odr(self, i, plot=False, eps=2): """Orthogonal distance regression for temporally concurrent points of overlapping time series. Uses :mod:`scipy.odr`. :param i: the 'join' index (``0`` is the index of the join between series ``0`` and ``1`` etc.) :param plot: whether or not to plot the given join :param eps: the ``eps`` param to be handed down to the :meth:`.dbscan` method for outlier detection :returns: dictionary with computed statistics, including the additive offset (key ``offs``) :rtype: :obj:`dict` """ c = self.var.iloc[:, i:i + 2].dropna(0, 'any') # outliers are detected from the differenc between the two series diff = c.diff(1, 1).values[:, 1] k, labels = self.dbscan(diff, True, True, eps=eps) x, y = c.iloc[k].values.T o = odr.ODR(odr.Data(x, y), odr.models.unilinear, beta0=[1, 0]).run() diff = diff[k] offs = np.nanmean(diff) m = np.argmin(abs(diff - offs)) + np.where(k)[0].min() self.starts[i + 1] += m self.ends[i] = self.starts[i + 1] - 1 if plot: fig, axs = plt.subplots(1, 2, figsize=(12, 5)) t = c.index.values.astype('datetime64[s]').astype(float).reshape( (-1, 1)) x, y = c.values.T for h in labels: pl = axs[0].plot(t[h], x[h], 'x')[0] axs[0].plot(t[h], y[h], '*', color=pl.get_color()) axs[1].plot(x[h], y[h], 'x') axs[1].plot(o.xplus, o.y, 'r-') axs[1].plot(x, y, 'mo', mfc='none') axs[1].yaxis.tick_right() plt.show() else: idx = c.index.symmetric_difference(c.index[k]) j = np.where(np.diff(idx) != self.delta)[0] if len(j) > 1: print('Complex outlier structure deteced at knot {}'.format(i)) elif len( j ) == 1: # means there are outliers on either end of the overlap self.out.loc[idx[:j[0] + 1], 'outliers'] = i + 1 self.out.loc[idx[j[0] + 1:], 'outliers'] = i elif len( idx ) > 0: # means there are outliers only in one of the two series self.out.loc[idx, 'outliers'] = i + int(idx[0] == c.index[0]) return { 'offs': offs, 'kind': 'mean', 'stdev': diff.std() / np.sqrt(len(diff)), 'odr_slope': o.beta[0], 'odr_offs': o.beta[1], 'RSS1': np.mean(o.delta**2), 'RSS2': np.mean(o.eps**2), }
def fit_circle(points): """ fits a circle to the given points. The method has been adapted from http://wiki.scipy.org/Cookbook/Least_Squares_Circle The function returns an instance of Circle """ def calc_dist(xc, yc): """ calculate the distance of each point from the center (xc, yc) """ return np.linalg.norm(points - np.array([[xc, yc]]), axis=0) def circle_implicit(beta, x): """ implicit definition of the circle """ return (x[0] - beta[0])**2 + (x[1] - beta[1])**2 - beta[2]**2 # coordinates of the bary center x_m, y_m = np.mean(points, axis=0) # initial guess for parameters R_m = calc_dist(x_m, y_m).mean() beta0 = [x_m, y_m, R_m] # for implicit function : # data.x contains both coordinates of the points (data.x = [x, y]) # data.y is the dimensionality of the response lsc_data = odr.Data(points.T, y=1) lsc_model = odr.Model(circle_implicit, implicit=True) lsc_odr = odr.ODR(lsc_data, lsc_model, beta0) lsc_out = lsc_odr.run() # collect result xc, yc, R = lsc_out.beta return shapes.Circle(xc, yc, R)
def fiting_test(): a = 2. b = 3. N = 10 x = np.linspace(-a, a, N) y = b * np.sqrt(1. - (x / a)**2) x += (2. * np.random.random(N) - 1.) * 0.1 y += (2. * np.random.random(N) - 1.) * 0.1 xx = np.array([x, y]) mdr = odr.Model(f, implicit=True) mydata = odr.Data(xx, y=1) myodr = odr.ODR(mydata, mdr, beta0=[1., 2.]) myoutput = myodr.run() myoutput.pprint() ax = plt.subplot(111, aspect='equal') plt.scatter(x, y) # raw data with randomness ell = Ellipse(xy=(0., 0.), width=2. * myoutput.beta[0], height=2. * myoutput.beta[1], angle=0.0) ell.set_facecolor('none') ax.add_artist(ell) # fitted curve plt.show()
def odRegress(x, y, weights=[], linreg=None): # Produce Orthogonal Data Reduction (fit) for the passed x,y pairings. # Returns: [fit parameters] , [parm. errors], [[covariance matrix]], # [estimated error in x vars], [estimated error in y vars] # Code modified from: Robin Wilson, see the site for copyright notice: # http://blog.rtwilson.com/orthogonal-distance-regression-in-python/ # # x,y both arrays of same length assert len(x) == len(y) if linreg is None: linreg = stats.linregress(x, y) # Linear function defined above model = odr.Model(Linear) if len(weights) != len(x): data = odr.Data(x, y=y) else: data = odr.Data(x, y=y, we=weights) # Bad variable naming, I know...so caps to avoid(?) confusion. :P ODR = odr.ODR(data, model, beta0=linreg[0:2]) out = ODR.run() return out.beta, out.sd_beta, out.cov_beta, out.delta, out.eps
def _odr(self, x, y, x_err, y_err): """Orthogonal distance regression (ODR). Parameters ---------- x : array x values y : array y values x_err : array x standard deviations y_err : array y standard deviations Returns ------- tuple Regression results """ lin_reg = self._linear_fit(x, y) linear_model = odr.Model(self._linear_func) data = odr.RealData(x, y, sx=x_err, sy=y_err) odr_fit = odr.ODR(data, linear_model, beta0=lin_reg[0:2]) out = odr_fit.run() slope = out.beta[0] intercept = out.beta[1] r2 = self._odr_r_squared(out.y, y) slope_std_err = out.sd_beta[0] intercept_std_err = out.sd_beta[0] return slope, intercept, r2, slope_std_err, intercept_std_err
def plot_lin_reg(X, Y, x_name, y_name, x_err=[], y_err=[]): ''' plot linear regression results :param x: data for x axis :param y: data for y axis :param intercept: returned intercept value from linear regression fit :param coeff: returned coefficient value from linear regression fit :return: None ''' X = X.to_numpy() Y = Y.to_numpy() #popt, pcov = curve_fit(line, X, Y, xerr=x_err, yerr=y_err) linear = odr.Model(f) mydata = odr.RealData(X, Y, sx=x_err, sy=y_err) myodr = odr.ODR(mydata, linear, beta0=[1., 0.2]) myoutput = myodr.run() linear_fit_x = np.linspace(np.min(X), 1.1 * np.max(X), 100) linear_fit_y = list( map(lambda x: x * myoutput.beta[0] + myoutput.beta[1], linear_fit_x)) #plotting fig, ax = plt.subplots() ax.plot(linear_fit_x, linear_fit_y) ax.errorbar(X, Y, xerr=x_err, yerr=y_err, color='coral', fmt='o', capsize=3, capthick=1, ecolor='coral') plt.xlabel(plot_names[x_name]) plt.ylabel(plot_names[y_name]) fig.show()
def line_fit(datax,datay,errory,beta0=[90,1]): mod = sdr.Model(line) dat = sdr.RealData(datax,datay,errory) odr = sdr.ODR(dat,mod,beta0=beta0) odr.set_job(fit_type=2) res = odr.run() return res
def perform_odr(add, dev, wadd, wdev, beta0=[0.]): """ A wrapper around scipy.ODR. Params: ------- add, dev: np.array x and y coordinates of the regression wadd, wdev: np.array standard deviations beta0: float initialization for ODR Output: ------- an ODR object """ def f(B, x): """A linear function for the ODR.""" return B * (x) linear = odr.Model(f) mydata = odr.RealData(add, dev, sx=wadd, sy=wdev) myodr = odr.ODR(mydata, linear, beta0=beta0) myoutput = myodr.run() if myoutput.stopreason[0] == 'Numerical error detected': print('Warning: Numerical error detected, ODR failed.') return myoutput
def gauss_fit(datax,datay,errory,beta0=[0,1,1,0,0]): mod = sdr.Model(gaussian) dat = sdr.RealData(datax,datay,sy=errory) odr = sdr.ODR(dat,mod,beta0=beta0) odr.set_job(fit_type=2) res = odr.run() return res
def ODR_Gauss_Fit(X,dX,Y,dY,guess): #print(X,dX,Y,dY,guess) if len(X) != len(Y): raise Exception("The vectors are not the same length! ") if len(X) < 3: raise Exception("Use at least 3 points! ") dX = np.array([dX]) dY = np.array([dY]) N = len(X) if len(dX) == 1: dX = dX*np.ones(N) if len(dY) == 1: dY = dY*np.ones(N) Gauss = odr.Model(ODR_Gauss_Fit_f) mydata = odr.RealData(X,y=Y,sx=dX,sy=dY) myodr = odr.ODR(mydata,Gauss,beta0 = guess,maxit=1000) myoutput = myodr.run() #myoutput.pprint() a = myoutput.beta[0] b = myoutput.beta[1] c = myoutput.beta[2] sa = myoutput.sd_beta[0] sb = myoutput.sd_beta[1] sc = myoutput.sd_beta[2] rchi2 = myoutput.res_var dof = N - len(myoutput.beta) chi2 = rchi2*dof P = 1 - scichi.cdf(chi2,dof) return a, sa, b, sb, c, sc, rchi2, P
def optimize_odr(self, data): """ Calculate the orthogonal distance regression for a dataset fitted to a circle Parameters ---------- data: 2D array x-y coordinates of all datapoints in all images Returns ------- calibration: float array array of midpoint coordinates and respective radii """ self.grid = data[0][1] self.grid_stack = np.array(list(self.grid) * len(data)) x = np.array(data)[:, 0, :].flatten() lsc_data = odr.Data(x, y=1) lsc_model = odr.Model(fcn=self.f_odr_multivariate, implicit=True, estimate=self.calc_estimate_odr_multivariate) lsc_odr = odr.ODR(lsc_data, lsc_model) lsc_out = lsc_odr.run() lsc_out.pprint() opt = lsc_out.beta calibration = [] for i in range(len(data)): xc = opt[i * 2] yc = opt[i * 2 + 1] r = opt[-1] package = [xc, yc, r] calibration.append(package) return calibration
def run_ODR(self, mag, phase, regressors=None): linearfit = odr.Model(self.multiplelinear) stdm, noise = self.get_noise_est(mag) stdp, _ = self.get_noise_est(phase) if regressors is not None: design = np.concatenate((phase[:, np.newaxis], regressors, np.ones_like(phase[:, np.newaxis])), axis=1).T ests = np.concatenate(([stdm/stdp], np.std(regressors, axis=0)/stdp, [np.mean(mag) / np.mean(phase)])) mydata = odr.RealData(design, mag, sx=np.concatenate(([stdp], np.std( regressors, axis=0), [1])), sy=stdm) else: design = np.row_stack((phase, np.ones(phase.shape))) ests = [np.std(mag) / np.std(phase), np.mean(mag) / np.mean(phase)] mydata = odr.RealData(design, mag, sx=np.hstack([stdp, np.finfo(stdp).eps]), sy=stdm) # and fit model # mag = A*phase + B*regressors + C # (y=mx+b) # call : (x,y,sx,sy) odr_obj = odr.ODR(mydata, linearfit, beta0=ests, maxit=400) res = odr_obj.run() return res, design
def odr_fit(x_data, x_data_err, y_data, y_data_err, fitfunc=double_power_law, initial_guesses=(100, -20, 0, -0.5)): """Fit data to a function using ODR fitting. Inputs: - x_data: Data along x-axis - x_data_err: Error of data along x-axis - y_data: Data along y-axis - y_data_err: Error in data along y-axis - fitfunc: Function to fit data to [default value = double_power_law] Returns: - ODR output object """ from scipy import odr # Instantiate classes for ODR run fit_func = odr.Model(fitfunc) mydata = odr.RealData(x_data, y_data, sx=x_data_err, sy=y_data_err) # Instantiate ODR myodr = odr.ODR(mydata, fit_func, beta0=initial_guesses) # Get output output = myodr.run() output.pprint() return output
def perform_odr(x,y,xerr,yerr): line=odr.Model(odr_line) mydata=odr.RealData(x,y,sx=xerr,sy=yerr) myodr=odr.ODR(mydata,line,beta0=[1.,0.]) myoutput=myodr.run() myoutput.pprint() return myoutput
def run(self): Model = odr.Model(self._linear) Data = odr.RealData(self._x, self._y, sx=self._dx, sy=self._dy) initial = self._initial_guess() solver = odr.ODR(Data, Model, initial) self.result = solver.run() return self.result.beta, self.result.sd_beta
def linreg(self, filtered_kym): linear_model = odr.Model(self.linear_function) x_points, y_points = np.nonzero(filtered_kym) mydata = odr.RealData(x_points, y_points) myodr = odr.ODR(mydata, linear_model, beta0=[0., 1.]) myodr.run() m, b = myodr.output.beta print(m, b) if b < 0: y0 = 0 x0 = int(-b / m) y1 = 1 x1 = int((1 - b) / m) elif b == 0: x0 = 0 y0 = 0 x1 = 1 y1 = m else: y0 = int(b) - 1 x0 = int((y0 - b) / m) y1 = int(b) - 2 x1 = int((y1 - b) / m) return [[x0, y0], [x1, y1]]
def fit(x,y): #Fit the data using scipy.odr fit_func = lambda B,x: B[0]*x + B[1] Model = odr.Model(fit_func) Data = odr.RealData(x, y) Odr = odr.ODR(Data, Model, beta0=[1,1]) return Odr.run()
def fit_ellipse(self, beta_i, num_fitting_pts=5000, ring_width=40, num_high_pix=20): ''' Fit an ellipse to a ring image ============================== beta_i - float tuple , ( x_center, y_center, x_radius, y_radius ) num_fitting_pts - int, number of pixels to include in fit ring_width - int, width ring-like region on image that contains ring of interest (pixels units) num_high_pix - int, remove this many pixels before running fit (removes artificial high pixels that might bias the fit) ''' r = sqrt((self.x - beta_i[0])**2 + (self.y - beta_i[1])**2) self.img[r > beta_i[2] + ring_width / 2] = 0 self.img[r < beta_i[2] - ring_width / 2] = 0 img1 = self.img.ravel() self._remove_highest(img1, num_high_pix) num_pts = where(img1 > 0)[0].shape[0] if num_fitting_pts >= num_pts: num_fitting_pts = num_pts / 2 inds = argsort(img1)[::-1][:num_fitting_pts] pts = row_stack([self.x1[inds], self.y1[inds]]) lsc_data = odr.Data(pts, y=1) lsc_odr = odr.ODR(lsc_data, self.ellipse_model, beta_i) lsc_out = lsc_odr.run() return lsc_out.beta
def MaritimeSummary_ODR(df): maritime = df[(df['Maritime'] == 1) & (abs(df['Lat']) <= 15)] subset = df[(df['Maritime'] == 1) & (abs(df['Lat']) > 35)] linmod = odr.Model(linreg) #instantiate with results of linear regression beta0 = [0.0012, 0.0059] y = subset['Slope'].values.astype(float) x = 10 * subset['Press'].values.astype(float) sx = subset['Slope_std'].values.astype(float) sy = subset['Press_std'].values.astype(float) realdata = odr.RealData(x, y, sx=sx, sy=sy) model = odr.ODR(realdata, linmod, beta0=beta0) results = model.run() print( 'Beta0: {}, Beta0 std: {}, Beta1: {}, Beta1 std: {}, inv condnum: {}, resvar: {}' .format(results.beta[0], results.sd_beta[0], results.beta[1], results.sd_beta[1], results.inv_condnum, results.res_var)) x = sm.add_constant(x) results = sm.OLS(y, x, missing='drop').fit() print(results.summary()) print('Results for d18O slopes vs Omega 500 slopes:') y = maritime['Slope'].values.astype(float) x = 10 * maritime['Omega'].values.astype(float) x = sm.add_constant(x) results = sm.OLS(y, x, missing='drop').fit() print(results.summary())
def perform_odr(x, y, xerr, yerr): quadr = odr.Model(odr_line) mydata = odr.Data(x, y, wd=1. / xerr, we=1. / yerr) #mydata = odr.Data(x, y) myodr = odr.ODR(mydata, quadr, beta0=[0., 0.]) output = myodr.run() return output
def hedge(df, days_moving_avg): # USED DEBUGGING y = np.asarray(df[stock1].tolist()[-days_moving_avg:]) # stock 1 data x = np.asarray(df[stock2].tolist()[-days_moving_avg:]) # stock 2 data # Fit the data using scipy.odr def f(B, x): return B[0] * x + B[1] linear = odr.Model(f) mydata = odr.RealData(x, y, sx=np.std(x), sy=np.std(y)) fit_np = np.polyfit(x, y, 1) print fit_np myodr = odr.ODR(mydata, linear, beta0=[fit_np[0], fit_np[1]]) # THINK ABOUT CHANGING BETA0 myoutput = myodr.run() # fit the data using numpy.polyfit # graph to compare the fit print 'polyfit beta', fit_np[0] print 'least errors beta', myoutput.beta[0] plt.plot(x, y, label='Actual Data', linestyle='dotted') # actual data points plt.plot(x, np.polyval(fit_np, x), "r--", lw=2, label='Polyfit') # polyfit regression line plt.plot(x, f(myoutput.beta, x), "g--", lw=2, label='Least Errors') # least errors regression line plt.legend(loc='lower right') plt.title('Linear Fit Through Historical Data') plt.show() # myoutput.pprint() # df["HedgeRatio"] = calculateHedgeRatio(df[]) return myoutput.beta[0] # returns the hedge ratio