def nonlinear_fit(d, e, initial_guess): """ d : list of values of the set of discretization parameters in each experiment: d = ((d_1,d_2,d_3),(d_1,d_2,d_3,),...) d[i] provides the values of the discretization parameters in experiement no. i e : list of error values; e = (e_1, e_2, ...) e[i] is the error associated with the parameters d[i] initial_guess is the starting value for the unknown parameters vector. """ if len(d) != len(e): raise ValueError, 'len(d) != len(e)' # transform d and e to the data format required by # the Scientific package: data = [] for d_i, e_i in zip(d, e): if isinstance(d_i, (float, int)): data.append(((d_i,), e_i)) else: # d_i is tuple, list, array, NumArray, ... data.append((d_i, e_i)) sol = leastSquaresFit(ManyDiscretizationPrm.error_model, initial_guess, data) # return list of fitted parameters (p in error_model) # (sol[1] is a measure of the quality of the fit) return sol[0]
def analyze(self, task): self.initialGuess(task) p = [self.coeff[c] for c in self.varCoeffs] (p, self.chisq) = leastSquaresFit(self.func, p, self.chooseXY(task)) for i in range(len(self.varCoeffs)): self.coeff[self.varCoeffs[i]] = p[i] del self.func
def nonlinear_fit(d, e, initial_guess): """ d : list of values of the (single) discretization parameter in each experiment: d[i] provides the values of the discretization parameter in experiement no. i e : list of error values; e = (e_1, e_2, ...) e[i] is the error associated with the parameters d[i] initial_guess is the starting value for the unknown parameters vector. """ if len(d) != len(e): raise ValueError, 'd and e must have the same length' if not isinstance(d[0], (float,int)): raise TypeError, \ 'd must be an array of numbers, not %s' % str(type(d[0])) # transform d and e to the data format required by # the Scientific package: data = [] for d_i, e_i in zip(d, e): data.append(((d_i,) , e_i)) # recall (a,) conversion to tuple sol = leastSquaresFit(OneDiscretizationPrm.error_model, initial_guess, data) return sol[0]
def fit(self): self.setStartParam() fitParam, chi = leastSquaresFit(self.func, self.startParam, self.data) fitData, akaike = self.akaike(fitParam) # wszystkie model oczekuja parametrow >= 0 if fitParam[0] <= 0: raise Exception, "alfa %f mniejsza od 0! " % fitParam[0] if len(fitParam) > 1 and fitParam[1] <= 0: raise Exception, "beta %f mniejsza od 0! " % fitParam[1] return (fitParam, chi, fitData, akaike)
def __call__(self, t, data, param = [10000, 200, 300000, 2000]): """ Sets the Star object parameters to the best fit. param can be changed for better performance. Be aware that there might be more than one fix point for each data-set, so inspect the result to see wheter it is a realistic fit. Usually this is no problem if the initializing parameters are sensible. """ # create list of tuples values = []; print len(data); print len(t); for i in range(len(t)): values.append([t[i], data[i]]); values = np.asarray(values); return leastSquaresFit(self.modelFunction, param, values)
def __call__(self, t, data, param=[10000, 200, 300000, 2000]): """ Sets the Star object parameters to the best fit. param can be changed for better performance. Be aware that there might be more than one fix point for each data-set, so inspect the result to see wheter it is a realistic fit. Usually this is no problem if the initializing parameters are sensible. """ # create list of tuples values = [] print len(data) print len(t) for i in range(len(t)): values.append([t[i], data[i]]) values = np.asarray(values) return leastSquaresFit(self.modelFunction, param, values)
def equilibrate(atoms, dyn, temp): print "Equilibrating ..." tstart = time.time() temperatures = [] for i in xrange(1,nequil/nminor+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms) temperatures.append((i*nminor*timestep, 2.0/3.0 * ekin)) if i % nequilprint == 0: #data = array(temperatures) #print data.shape try: (a, b, c) = leastSquaresFit(targetfunc, (0.1, 2*frict, temp), temperatures)[0] except OverflowError: print "leastSquaresFit failed (this is OK)." a = b = c = 0.0 print "%.6f T_inf = %.6f (goal: %f) k = %.6f" % \ (ekin, c, temp, b) tequil = time.time() - tstart print "This took %.1f minutes." % (tequil / 60) print "Taking data - this takes", repeats*nsteps/nequil, "times longer!"
C = 1 a = 2 D = 2 b = 1 p = (C, a, D, b) dx = 0.5 dt = 1.0 for i in range(7): dx /= 2 dt /= 2 e = error_model(p, (dx, dt)) # use the model to generate data e += random.gauss(0, 0.01 * e) # perturb data randomly data.append(((dx, dt), e)) from Scientific.Functions.LeastSquares import leastSquaresFit parameter_guess = (1, 2, 2, 1) # exact guess... r = leastSquaresFit(error_model, parameter_guess, data) print r # try different initial guesses: array_output_precision(4) for i in range(6): pg = array(p, Float) + i * 0.1 * sign(random.uniform(-1, 1)) * ones(4, Float) r = leastSquaresFit(error_model, pg, data) print "guess:", str(pg) deviation = array(p) - array(r[0]) print " deviation:", deviation import sys sys.exit(0)
def rateFilter(sampledRGB, filterRadius, exposedTime, flowRate, bcgradient, gradient, parenttags=None, level=logging.ERROR): ''' Computes the BCArea and BCVolume subject to the params Keyword arguments: sampledRGB -- The sampled RGB values of the BCFilter exposedTime -- The duration for which the filter was exposed to air from the pump flowRate -- The flow rate of the pump bcgradient -- The calibration value obtained from the database gradient -- The values corresponding to the color values from GrayBar objects parenttags -- The tag string of the calling function level -- The logging level Returns: BCCResult object ''' # Set the logging level log.setLevel(level) tags = parenttags + " BCCCOMPUTATION" try: fitParam = BCCCalculatorConstants.FittingParameters stop = BCCCalculatorConstants.StoppingLimit expmod = Rating.expmod rsquared = Rating.rsquared # The results of this computation bccResult = BCCResult() # separate by color leaving off the black and white gradientRed, gradientGreen, gradientBlue = zip(*gradient[1:-1]) # fit the gradient bccResult.fitRed, chi = leastSquaresFit(expmod, fitParam, zip(gradientRed, bcgradient), stopping_limit=stop) bccResult.fitGreen, chi = leastSquaresFit(expmod, fitParam, zip(gradientGreen, bcgradient), stopping_limit=stop) bccResult.fitBlue, chi = leastSquaresFit(expmod, fitParam, zip(gradientBlue, bcgradient), stopping_limit=stop) # compute the rsquared value bccResult.rSquaredRed = rsquared(expmod, bccResult.fitRed, pylab.array(gradientRed), bcgradient) bccResult.rSquaredGreen = rsquared(expmod, bccResult.fitGreen, pylab.array(gradientRed), bcgradient) bccResult.rSquaredBlue = rsquared(expmod, bccResult.fitBlue, pylab.array(gradientRed), bcgradient) red, green, blue = sampledRGB bccResult.BCAreaRed = expmod(bccResult.fitRed, red) bccResult.BCAreaGreen = expmod(bccResult.fitGreen, green) bccResult.BCAreaBlue = expmod(bccResult.fitBlue, blue) log.info('Computing Black Carbon Concentration: ', extra=tags) bccResult.BCVolRed = computeBCC(filterRadius, bccResult.BCAreaRed, exposedTime ,flowRate) bccResult.BCVolGreen = computeBCC(filterRadius, bccResult.BCAreaGreen, exposedTime, flowRate) bccResult.BCVolBlue = computeBCC(filterRadius, bccResult.BCAreaBlue, exposedTime, flowRate) log.info('Black carbon per cm^2: %s', ([bccResult.BCAreaRed, bccResult.BCAreaGreen, bccResult.BCAreaBlue],), extra=tags) log.info('Black carbon per cm^3: %s', ([bccResult.BCVolRed, bccResult.BCVolGreen, bccResult.BCVolBlue],), extra=tags) log.info('Done Computing Black Carbon Concentration: ', extra=tags) return bccResult, ExitCode.Success except Exception, err: log.error('Error %s' % str(err), extra=tags) return None, ExitCode.BCCComputationError
def fit(self): """ Determine of data for optimal fit and fit """ Yr = [x.real for x in self.admitance] maxYr = max(Yr) maxYrIndex = Yr.index(maxYr) fRes = self.frequency[maxYrIndex] # Hladanie P% +- bodov P = 10 minYr = min(Yr) hod = maxYr - (((maxYr - minYr) / 100) * P) lava = maxYrIndex for i in range(maxYrIndex, 0, -1): if Yr[i] > hod: lava = i prava = maxYrIndex for i in range(maxYrIndex, len(self.frequency), 1): if Yr[i] > hod: prava = i #prava = maxYrIndex + (maxYrIndex - lava) # vyrez self.vyrez = Yr[lava:prava] self.vyref = self.frequency[lava:prava] self.vyref_fit = [] for i in range(len(self.vyref)): self.vyref_fit.append(i) # Fitovanie Realnej zlozky admitancie datafit = [] for i in range(len(self.vyref)): datafit.append((i, self.vyrez[i])) guess = (1, 1, 1) fit_params, fit_error = leastSquaresFit(func, guess, datafit) #print fit_params, fit_error self.fResonanceFit = (- fit_params[1] ) / (2 * fit_params[0]) * ((self.vyref[-1] - self.vyref[0]) / (len(self.vyref) - 1)) + self.vyref[0] #print self.fResonanceFit for i in range(len(self.vyref)): self.yre_fit.append(func(fit_params, i)) maxY = max(self.yre_fit) indexmax = self.yre_fit.index(max(self.yre_fit)) self.fResonance = self.vyref[indexmax] # fitovanie Imaginarnej zlozky admitancie Yi = [x.imag for x in self.admitance] self.vyrezimag = Yi[lava:prava] datafitimag = [] for i in range(len(self.vyref)): datafitimag.append((i, self.vyrezimag[i])) guessimag = (-1.0, 1.0) fit_params, fit_error = leastSquaresFit(funcimag, guessimag, datafitimag) #print fit_params, fit_error xim = [] for i in range(len(self.vyref)): xim.append(self.vyref[i]) self.yim_fit.append(funcimag(fit_params, i)) Yimag = self.yim_fit[indexmax] # Determine R1 self.R1 = 1.0 / maxY # Determine C0 w0 = 2 * math.pi * self.fResonance self.C0 = Yimag / w0 # Find X1 w = [] for f in self.frequency[lava:prava]: w.append(2 * math.pi * f) Yinn = [] # z ofitovanych hodnot real a imag urobi komplexne cislo... for i in range(len(self.vyref)): Yinn.append(self.yre_fit[i] + 1j * self.yim_fit[i]) X1 = [] for i in range(len(self.frequency[lava:prava])): X1.append((1 / (Yinn[i] - 1j * w[i] * self.C0)).imag) # Determine C1 C1 = [] f1 = [] for i in range(len(X1)): try: C1.append((((w[i] / w0) ** 2) - 1) / (w[i] * X1[i])) f1.append(self.frequency[lava + i]) except ZeroDivisionError: pass #self.C1 = Numeric.average(C1) ISVOSA - OLD self.C1 = numpy.average(C1) #Determine L1 self.L1 = 1.0 / (self.C1 * (w0 ** 2))
D = 2 b = 1 p = (C, a, D, b) dx = 0.5 dt = 1.0 for i in range(7): dx /= 2 dt /= 2 e = error_model(p, (dx, dt)) # use the model to generate data e += random_number.gauss(0, 0.01 * e) # perturb data randomly data.append(((dx, dt), e)) from Scientific.Functions.LeastSquares import leastSquaresFit parameter_guess = (1, 2, 2, 1) # exact guess... r = leastSquaresFit(error_model, parameter_guess, data) print r # try different initial guesses: for i in range(6): # exact p +/- [1-6]*(randomly chosen -1 or 1): pg = array(p, float) + i * 0.05 * sign(random_number.uniform(-1, 1)) * ones(4) r = leastSquaresFit(error_model, pg, data) print "guess:", str(pg) deviation = array(p) - array(r[0]) print " deviation:", deviation print "\n\nTesting statistical computations:" import Scientific.Statistics as S nsamples = 100000 data = random.normal(1.0, 0.5, nsamples)
def test(temp, frict): output = file('Langevin.dat', 'w') # Make a small perturbation of the momenta atoms.set_momenta(1e-6 * np.random.random([len(atoms), 3])) print 'Initializing ...' predyn = VelocityVerlet(atoms, 0.5) predyn.run(2500) dyn = Langevin(atoms, timestep, temp, frict) print '' print ('Testing Langevin dynamics with T = %f eV and lambda = %f' % (temp, frict)) ekin = atoms.get_kinetic_energy()/len(atoms) print ekin output.write('%.8f\n' % ekin) print 'Equilibrating ...' # Initial guesses for least-squares fit a = 0.04 b = 2*frict c = temp params = (a,b,c) fitdata = [(0, 2.0 / 3.0 * ekin)] tstart = time.time() for i in xrange(1,nequil+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms) fitdata.append((i*nminor*timestep, 2.0/3.0 * ekin)) if usescipy and i % nequilprint == 0: (params, chisq) = leastSquaresFit(targetfunc, params, fitdata) print '%.6f T_inf = %.6f (goal: %f), tau = %.2f, k = %.6f' % \ (ekin, params[2], temp, 1.0/params[1], params[0]) output.write('%.8f\n' % ekin) tequil = time.time() - tstart print 'This took %s minutes.' % (tequil / 60) output.write('&\n') assert abs(temp-params[2]) < 0.25*temp, 'Least-squares fit is way off' assert nequil*nminor*timestep > 3.0/params[1], 'Equiliberation was too short' fitdata = np.array(fitdata) print 'Recording statistical data - this takes ten times longer!' temperatures = [] tstart = time.time() for i in xrange(1,nsteps+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms) temperatures.append(2.0/3.0 * ekin) if i % nprint == 0: tnow = time.time() - tstart tleft = (nsteps-i) * tnow / i print '%.6f (time left: %.1f minutes)' % (ekin, tleft/60) output.write('%.8f\n' % ekin) output.write('&\n') output.close() temperatures = np.array(temperatures) mean = sum(temperatures) / len(temperatures) print 'Mean temperature:', mean, 'eV' print print 'This test is statistical, and may in rare cases fail due to a' print 'statistical fluctuation.' print assert abs(mean - temp) <= reltol*temp, 'Deviation is too large.' print 'Mean temperature:', mean, ' in ', temp, ' +/- ', reltol*temp return fitdata, params, temperatures