def testMonteCarlo1(self):
print("====== MonteCarlo 1 ===================")
N = 100
ran = numpy.random
ran.seed(12345)
noise = ran.standard_normal(N)
x = numpy.arange(N, dtype=float) - 3
nn = 0.1
for k in range(5):
y = noise * nn
m = PolynomialModel(0)
ftr = Fitter(x, m)
par = ftr.fit(y)
std = ftr.getStandardDeviations()
chisq = ftr.chisq
mc = MonteCarlo(x, m, ftr.covariance)
mc.mcycles = 1000
lmce = ftr.monteCarloError(monteCarlo=mc)
print("noise : ", fmt(nn),
"===========================================")
print("params : ", fmt(par, format="%8.5f"))
print("stdevs : ", fmt(std, format="%8.5f"))
print("scale : ", fmt(ftr.scale, format="%8.5f"), fmt(nn))
print("chisq : ", fmt(chisq, format="%8.5f"),
fmt(mc._eigenvalues, format="%8.5f"),
fmt(mc._eigenvectors, format="%8.5f"))
print("covar : ", fmt(ftr.covariance, format="%8.5f"))
print("mcerr : ", fmt(lmce[0], format="%8.5f"))
self.assertTrue(abs(std[0] - lmce[0]) < 0.1 * std[0])
self.assertTrue(par[0] < 0.05 * nn)
nn *= 10
def testMonteCarlo3(self, doplot=False):
print("====== MonteCarlo 3 ===================")
N = 101
x = numpy.arange(N, dtype=float) * 0.1
ran = numpy.random
ran.seed(1235)
noise = ran.standard_normal(N)
ym = x * x + 0.03 * x + 0.05
y1 = ym + 10 * noise
pm = PolynomialModel(2)
ftr = Fitter(x, pm)
pars1 = ftr.fit(y1)
stdv1 = ftr.getStandardDeviations()
print("parameters : ", pars1)
print("std devs : ", stdv1)
print("chisquared : ", ftr.chisq)
lmce = ftr.monteCarloError()
chisq = ftr.chisq
mce = MonteCarlo(x, pm, ftr.covariance)
mce1 = mce.getError()
assertAAE(lmce, mce1)
yfit = pm.result(x)
s2 = numpy.sum(numpy.square((yfit - ym) / lmce))
print(s2, math.sqrt(s2 / N))
integral = numpy.sum(yfit)
s1 = 0
s2 = 0
k = 0
for k in range(1, 100001):
rv = mce.randomVariant(x)
s1 += numpy.sum(rv)
s2 += numpy.sum(numpy.square(rv - yfit))
if k % 10000 == 0:
print("%6d %10.3f %10.3f %10.3f" %
(k, integral, s1 / k, math.sqrt(s2 / k)))
### TBC dont know why the factor 1000 is there. ########
print(abs(integral - s1 / k), math.sqrt(s2 / (k * 1000)))
self.assertTrue(abs(integral - s1 / k) < math.sqrt(s2 / (k * 1000)))
if doplot:
pyplot.plot(x, y1, 'b.')
pyplot.plot(x, ym, 'k-')
pyplot.plot(x, yfit, 'g-')
pyplot.plot(x, yfit + lmce, 'r-')
pyplot.plot(x, yfit - lmce, 'r-')
pyplot.show()
def test2_1( self, plot=False ) :
print( "====test2_1============================" )
nn = 100
x = numpy.arange( nn, dtype=float ) / 50
ym = 0.2 + 0.5 * x
nf = 0.1
numpy.random.seed( 2345 )
noise = numpy.random.randn( nn )
y = ym + nf * noise
limits = [-1,2]
pm = PolynomialModel( 1 )
bf = Fitter( x, pm )
pars = bf.fit( y )
logz0 = bf.getLogZ( limits=limits )
logl0 = bf.logLikelihood
print( "pars ", fmt( pars ) )
print( "stdv ", fmt( bf.stdevs ) )
print( "logZ ", fmt( logz0 ), " logL ", fmt( logl0 ) )
errdis = GaussErrorDistribution ( x, y )
logz1, logl1 = plotErrdis2d( errdis, pm, limits=limits, max=0,
plot=plot )
if plot :
plt.plot( pars[0], pars[1], 'k.' )
print( "logZ ", fmt( logz1 ), " logL ", fmt( logl1 ) )
model = PolynomialModel( 1 )
model.setLimits( lowLimits=limits[0], highLimits=limits[1] )
ns = NestedSampler( x, model, y, verbose=0 )
yfit = ns.sample()
par2 = ns.parameters
logz2 = ns.logZ
dlz2 = ns.logZprecision
print( "pars ", fmt( par2 ) )
print( "stdv ", fmt( ns.stdevs ) )
print( "logZ ", fmt( logz2 ), " +- ", fmt( dlz2 ) )
self.assertTrue( abs( logz2 - logz0 ) < dlz2 )
# print( logz0 - logz1, logz0 - logz2 )
samples = ns.samples
parevo =samples.getParameterEvolution()
llevo = samples.getLogLikelihoodEvolution()
lwevo = samples.getLogWeightEvolution()
assertAAE( numpy.sum( numpy.exp( lwevo ) ), 1.0 )
if plot :
plt.show()
def __init__(self):
plott = Plotter()
QtGui.QMainWindow.__init__(self)
self.setWindowIcon(QtGui.QIcon('phyton.ico'))
self.setupUi(self)
self.fit = Fitter()
self.gen = Generator()
self.plot = Plotter()
self.fitted_args = []
self.chi2 = None
self.chi2Error = 0.5
def __init__(self):
plott = Plotter()
QtGui.QMainWindow.__init__(self)
self.setWindowIcon(QtGui.QIcon('phyton.ico'))
self.setupUi(self)
self.fit = Fitter()
self.gen = Generator()
self.plot = Plotter()
self.fitted_args = []
self.chi2 = None
self.chi2Error = 0.5
def run_training():
device = torch.device('cuda:0')
train_loader = torch.utils.data.DataLoader(
train_dataset,
sampler=BalanceClassSampler(labels=train_dataset.get_labels(), mode="downsampling"),
batch_size=TrainGlobalConfig.batch_size,
pin_memory=False,
drop_last=True,
num_workers=TrainGlobalConfig.num_workers,
)
val_loader = torch.utils.data.DataLoader(
validation_dataset,
batch_size=TrainGlobalConfig.batch_size,
num_workers=TrainGlobalConfig.num_workers,
shuffle=False,
sampler=SequentialSampler(validation_dataset),
pin_memory=False,
)
fitter = Fitter(model=net, device=device, config=TrainGlobalConfig)
# fitter.load(f'{fitter.base_dir}/last-checkpoint.bin')
fitter.fit(train_loader, val_loader)
def testNormalize(self, plot=False):
"""
test normalized parameter, alternative for keepfixed.
1.
2.
"""
print("\n Fitter Test 2 Normalize \n")
model = PolynomialModel(2)
sm = PowerModel(1.0)
x = numpy.linspace(0.0, 10.0, 101)
y = 1.0 + 0.5 * x - 0.2 * x * x + numpy.random.randn(101) * 0.1
sm += model ## degenerate model par[0] == par[2]
fitter = Fitter(x, sm)
self.assertTrue(sm.npchain == 4)
self.assertRaises(numpy.linalg.linalg.LinAlgError, fitter.fit, y)
fitter.normalize([0.0, 0.0, 1.0, 0.0], 1.0) ## fix par[2] at 1.0
par = fitter.fit(y)
print("param = ", sm.parameters)
assertAAE(par[2], 1.0)
assertAAE(par, [-0.5, 1.0, 1.0, -0.2], 1)
chisq = fitter.chisq
print("chisq = %f" % (chisq))
std = fitter.standardDeviations
print("stdev = ", std)
def testMonteCarlo2(self, doplot=False):
print("====== MonteCarlo 2 ===================")
x = numpy.arange(7, dtype=float) - 3
y = numpy.asarray([-1, -1, -1, 0, 1, 1, 1], dtype=float)
m = PolynomialModel(1)
ftr = Fitter(x, m)
par = ftr.fit(y)
std = ftr.getStandardDeviations()
yfit = m.result(x)
chisq = ftr.chisq
hes = ftr.hessian
# mc = MonteCarlo( x, m, chisq, hessian=hes )
mc = MonteCarlo(x, m, ftr.covariance)
mc.mcycles = 1000
lmce = ftr.monteCarloError(monteCarlo=mc)
print("params : ", par)
print("stdevs : ", std)
print("scale : ", ftr.getScale())
print("chisq : ", chisq)
print("evals : ", mc._eigenvalues)
print(mc._eigenvectors)
print("hessi :\n", ftr.hessian)
print("covar :\n", ftr.covariance)
print("mcerr : ", lmce)
numpy.testing.assert_array_almost_equal(
par, numpy.asarray([0.0, 0.42857142857142855]))
# numpy.testing.assert_array_almost_equal( std, numpy.asarray([0.1564921592871903,0.07824607964359515]) )
self.assertAlmostEqual(chisq, 0.857142857143)
if doplot:
pyplot.plot(x, y, 'k*')
pyplot.plot(x, yfit, 'g-')
pyplot.plot(x, yfit + lmce, 'r-')
pyplot.plot(x, yfit - lmce, 'r-')
pyplot.show()
len(large_bins_sig_fit) - 1, array('d', large_bins_sig_fit),
"mjjbins_sig")
#Fit to signal events only (Can we make this optional?)
#Signal data preparation
histos_sig = ROOT.TH1F("mjj_sig", "mjj_sig",
len(bins_sig_fit) - 1, bins_sig_fit)
load_h5_sig(options.inputFile, histos_sig, mass)
print "************ Found", histos_sig.GetEntries(), "signal events"
print
print "########## FIT SIGNAL AND SAVE PARAMETERS ############"
sig_outfile = ROOT.TFile("sig_fit.root", "RECREATE")
fitter = Fitter(['mjj_fine'])
fitter.signalResonance('model_s', "mjj_fine", mass)
fitter.w.var("MH").setVal(mass)
fitter.importBinnedData(histos_sig, ['mjj_fine'], 'data')
fres = fitter.fit('model_s', 'data', [ROOT.RooFit.Save(1)])
#fres.Print()
mjj_fine = fitter.getVar('mjj_fine')
mjj_fine.setBins(len(bins_sig_fit))
chi2_fine = fitter.projection("model_s", "data", "mjj_fine",
plot_dir + "signal_fit.png")
fitter.projection("model_s", "data", "mjj_fine",
plot_dir + "signal_fit_log.png", 0, True)
chi2 = fitter.projection("model_s", "data", "mjj_fine",
plot_dir + "signal_fit_binned.png",
roobins_sig_fit)
def testEvidence(self):
print("====testEvidence======================")
x = np.arange(11, dtype=float) - 5
pm = PolynomialModel(1)
bf = Fitter(x, pm)
np.random.seed(12345)
y = 0.2 + 0.3 * x + np.random.randn(11) * 0.1
w = np.ones(11, dtype=float)
par = bf.fit(y, w)
print("chisq %f scale %f sumwgt %f" %
(bf.chisq, bf.scale, bf.sumwgt))
lolim = [-10.0, -10.0]
hilim = [+10.0, +10.0]
print("= 0 ====== Parameters only")
evi0 = bf.getLogZ(limits=[lolim, hilim])
occ0 = bf.logOccam
lhd0 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi0, occ0, lhd0))
self.assertTrue(
bf.getEvidence(limits=[-10.0, 10.0]) == evi0 / math.log(10.0))
nslim = [0.01, 10.0]
print("= 1 ====== Parameters and scale")
evi1 = bf.getLogZ(limits=[-10.0, 10.0], noiseLimits=nslim)
occ1 = bf.logOccam
lhd1 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi1, occ1, lhd1))
self.assertTrue(bf.fixedScale is None)
self.assertRaises(AttributeError, bf.__getattr__, "minimumScale")
print("= 2 ====== Parameters and fixed scale = 0.01")
bf.fixedScale = 0.01
evi2 = bf.getLogZ(limits=[lolim, hilim])
occ2 = bf.logOccam
lhd2 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi2, occ2, lhd2))
self.assertFalse(bf.fixedScale is None)
self.assertRaises(AttributeError, bf.__getattr__, "minimumScale")
print("= 3 ====== Parameters and fixed scale = 0.1")
bf.fixedScale = 0.1
evi3 = bf.getLogZ(limits=[lolim, hilim])
occ3 = bf.logOccam
lhd3 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi3, occ3, lhd3))
print("= 4 ====== Parameters and fixed scale = 1.0")
bf.fixedScale = 1.0
evi4 = bf.getLogZ(limits=[lolim, hilim])
occ4 = bf.logOccam
lhd4 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi4, occ4, lhd4))
print("= 5 ====== Parameters and fixed scale = 10.0")
bf.fixedScale = 10.0
evi5 = bf.getLogZ(limits=[lolim, hilim])
occ5 = bf.logOccam
lhd5 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi5, occ5, lhd5))
self.assertFalse(bf.fixedScale is None)
# no noiseLimit is the same as fixedScale=1.0
self.assertTrue(evi0 == evi4)
self.assertTrue(occ0 == occ4)
self.assertTrue(lhd0 == lhd4)
# evidence with the `right' fixed scale is the best; better than auto scale
self.assertTrue(evi3 > evi1) # auto scaling
self.assertTrue(evi3 > evi2) # scale = 0.01
self.assertTrue(evi3 > evi4) # scale = 1.0
self.assertTrue(evi3 > evi5) # scale = 10.0
print("======= limits inside the model ")
pm.setLimits(lolim, hilim)
print("limits par[0] ", pm.priors[0].lowLimit, pm.priors[0].highLimit)
print("limits par[1] ", pm.priors[1].lowLimit, pm.priors[1].highLimit)
print("ranges ", pm.priors[0]._range, pm.priors[1]._range)
self.assertTrue(pm.priors[0]._range == 20.0)
self.assertTrue(pm.priors[1]._range == 20.0)
bf.fixedScale = None
evi6 = bf.getLogZ()
occ6 = bf.logOccam
lhd6 = bf.logLikelihood
print("evid %f occam %f lhood %f" % (evi0, occ0, lhd0))
self.assertTrue(bf.getEvidence() == evi0 / math.log(10.0))
# no noiseLimit is the same as fixedScale=1.0
self.assertTrue(evi0 == evi6)
self.assertTrue(occ0 == occ6)
self.assertTrue(lhd0 == lhd6)
def test1( self, plot=False ) :
print( "====test1============================" )
nn = 100
x = numpy.zeros( nn, dtype=float )
ym = 0.2 + 0.5 * x
nf = 1.0
nf = 0.1
numpy.random.seed( 2345 )
noise = numpy.random.randn( nn )
y = ym + nf * noise
limits = [-2,2]
pm = PolynomialModel( 0 )
bf = Fitter( x, pm )
pars = bf.fit( y )
logz0 = bf.getLogZ( limits=limits )
logl0 = bf.logLikelihood
print( "pars ", fmt( pars ) )
print( "stdv ", fmt( bf.stdevs ) )
print( "logZ ", fmt( logz0 ) )
print( "logl ", fmt( logl0 ) )
errdis = GaussErrorDistribution ( x, y )
logz1, maxll = plotErrdis( errdis, pm, limits=limits,
max=0, plot=plot )
print( "logZ ", fmt( logz1 ) )
model = PolynomialModel( 0 )
model.setLimits( lowLimits=limits[0], highLimits=limits[1] )
ns = NestedSampler( x, model, y )
yfit = ns.sample()
par2 = ns.parameters
stdv = ns.stdevs
logz2 = ns.logZ
dlz2 = ns.logZprecision
print( "pars ", fmt( par2 ) )
print( "stdv ", fmt( stdv ) )
print( "logZ ", fmt( logz2 ), " +- ", fmt( dlz2 ) )
self.assertTrue( abs( logz2 - logz0 ) < dlz2 )
samples = ns.samples
parevo =samples.getParameterEvolution()
llevo = samples.getLogLikelihoodEvolution()
lwevo = samples.getLogWeightEvolution()
assertAAE( numpy.sum( numpy.exp( lwevo ) ), 1.0 )
if plot :
plt.plot( parevo, numpy.exp( llevo ), 'r,' )
mxl = numpy.exp( numpy.max( llevo ) ) * 1.2
plt.plot( [pars,pars], [0.0,mxl], 'b-' )
plt.plot( [par2,par2], [0.0,mxl], 'r-' )
plt.plot( [par2,par2]+stdv, [0.0,mxl], 'g-' )
plt.plot( [par2,par2]-stdv, [0.0,mxl], 'g-' )
plt.show()
from multiprocessing import Pool
from DataProcessing import DataCleaner
from Fitter import Fitter
from Simulation import Simulation
from PerformanceMetrics import DescriptiveStatistics
vector = [15, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34]
# Import training data instance
dataTrain = DataCleaner('TRAIN', merge_new_data=True)
fit = Fitter(dataTrain)
fit.fit_theo_CorrBBO()
fit.fit_theo_HL()
# fit = Fitter(dataTrain)
# # Find model parameters
# if __name__ == '__main__':
# with Pool(processes=6) as p:
# p.map(fit.fit_theo_eOmniPresent, vector)
# Import test data instance
dataTest = DataCleaner('TEST')
# Simulate using test data
sim = Simulation(dataTest)
sim.pred_theo_midprice()
sim.pred_theo_smartp()
sim.pred_theo_weigted_mid()
sim.pred_theo_smart_mid()
sim.pred_theo_HL()
class Ui_MainWindow(QtGui.QMainWindow):
def __init__(self):
plott = Plotter()
QtGui.QMainWindow.__init__(self)
self.setWindowIcon(QtGui.QIcon('phyton.ico'))
self.setupUi(self)
self.fit = Fitter()
self.gen = Generator()
self.plot = Plotter()
self.fitted_args = []
self.chi2 = None
self.chi2Error = 0.5
#Funkcja odpowiedzialna za wywolanie funkcji tworzacej nowy wykres z klasy Plotter
#oraz wstawienie go w GUI
def DrawPlot(self):
Plotter.dopasowana = self.checkBox_dopasowana.isChecked()
Plotter.poczatkowa = self.checkBox_poczatkowa.isChecked()
Plotter.dane = self.checkBox_dane.isChecked()
Plotter.xlim_min = self.spinbox_zakresOd.value()
Plotter.xlim_max = self.spinbox_zakresDo.value()
self.tabWidget.removeTab(0)
self.newTab = QtGui.QWidget()
self.newTab.setObjectName(_fromUtf8("plot"))
self.tabWidget.insertTab(0, self.newTab, _fromUtf8("Wykres"))
self.tabWidget.setCurrentWidget(self.newTab)
layout = QtGui.QVBoxLayout()
fig = self.plot.plot(self.gen.returnX(), self.gen.returnY(),
self.gen.returnYn(), self.fit.returnFittedData())
layout.addWidget(FigureCanvasQTAgg(fig))
self.newTab.setLayout(layout)
print 'Plot created.'
#Funkcja uruchamiana po uzyciu przycisku generujacego wykres w GUI
#Odpowiedzialna za kolejne uruchomienie wszystkich funkcje z zaimportowanych klas
def start(self):
print 'Generating data...'
#przekazanie danych ze spinboxow (z interfejsu) do generatora danych
self.gen.getData(self.spinbox_amp.value(), self.spinbox_freq.value(),
self.spinbox_ilePkt.value(),
self.spinbox_rozrzut.value(),
self.spinbox_przesuniecie.value(),
self.spinbox_zakresOd.value(),
self.spinbox_zakresDo.value())
# #uruchamianie kreatora
self.gen.creator()
#przekazywanie danych do fittera
self.fit.getData(self.gen.returnX(), self.gen.returnYn())
chio = None
oneMoreGuess = 0
#iteracyjne poszukiwanie odpowiedniej czestotliwosci, dobierane na podstawie porownania z wartoscia chi2
print "Fitting..."
while ((chio == None) or (chio > self.chi2Error)) and (
oneMoreGuess < self.spinbox_freq.maximum()):
#dopasowywanie funkcji
self.fit.fit(self.fit.guess(oneMoreGuess))
chio = Stats.chi(self.gen.returnY(), self.fit.returnFittedData())
oneMoreGuess += 0.1
self.chi2 = chio
if self.chi2 <= self.chi2Error:
print 'Fitting status: OK'
else:
print 'Fitting status: Failure'
#wydrukowanie zfitowanych wartosci
self.fitted_args = self.fit.printfitted_args()
#tworzenie plottera
print 'Drawing plot...'
self.DrawPlot()
#aktualizacja GUI
self.UpdateGui()
print 'All done.'
print '-----------------'
#Funkcja akutalizujaca informacje w gui
def UpdateGui(self):
self.chi_value.setText(str(round(self.chi2, 6)))
self.amp_value.setText(str(round(self.fitted_args[0], 6)))
self.freq_value.setText(str(round(self.fitted_args[1], 6)))
self.przes_value.setText(str(round(self.fitted_args[2], 6)))
#Funkcja inicjalizujaca spinboxy
def initSpinBox(self):
self.spinbox_amp.setValue(1)
self.spinbox_freq.setValue(1)
self.spinbox_rozrzut.setValue(0.1)
self.spinbox_ilePkt.setValue(500)
self.spinbox_zakresOd.setValue(0)
self.spinbox_zakresDo.setValue(10)
self.spinbox_przesuniecie.setValue(0)
#Funkcje odpowiedzialne za tworzenie GUI
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.setFixedSize(914, 523)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.tabWidget = QtGui.QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(QtCore.QRect(350, 30, 531, 371))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tab = QtGui.QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
self.spinbox_rozrzut = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_rozrzut.setGeometry(QtCore.QRect(190, 230, 62, 22))
self.spinbox_rozrzut.setObjectName(_fromUtf8("spinbox_rozrzut"))
self.iloscPkt_label = QtGui.QLabel(self.centralwidget)
self.iloscPkt_label.setGeometry(QtCore.QRect(70, 200, 81, 21))
self.iloscPkt_label.setObjectName(_fromUtf8("iloscPkt_label"))
self.rozrzutPkt_label = QtGui.QLabel(self.centralwidget)
self.rozrzutPkt_label.setGeometry(QtCore.QRect(70, 230, 101, 21))
self.rozrzutPkt_label.setObjectName(_fromUtf8("rozrzutPkt_label"))
self.zakresOd_label = QtGui.QLabel(self.centralwidget)
self.zakresOd_label.setGeometry(QtCore.QRect(70, 260, 71, 21))
self.zakresOd_label.setObjectName(_fromUtf8("zakresOd_label"))
self.zakresDo_label = QtGui.QLabel(self.centralwidget)
self.zakresDo_label.setGeometry(QtCore.QRect(230, 260, 21, 21))
self.zakresDo_label.setObjectName(_fromUtf8("zakresDo_label"))
self.spinbox_zakresOd = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_zakresOd.setGeometry(QtCore.QRect(160, 260, 62, 22))
self.spinbox_zakresOd.setObjectName(_fromUtf8("spinbox_zakresOd"))
self.spinbox_zakresDo = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_zakresDo.setGeometry(QtCore.QRect(250, 260, 62, 22))
self.spinbox_zakresDo.setObjectName(_fromUtf8("spinbox_zakresDo"))
self.spinbox_ilePkt = QtGui.QSpinBox(self.centralwidget)
self.spinbox_ilePkt.setGeometry(QtCore.QRect(190, 200, 61, 22))
self.spinbox_ilePkt.setObjectName(_fromUtf8("spinbox_ilePkt"))
self.rozklad_label = QtGui.QLabel(self.centralwidget)
self.rozklad_label.setGeometry(QtCore.QRect(70, 170, 161, 21))
self.rozklad_label.setObjectName(_fromUtf8("rozklad_label"))
self.funkcja_label = QtGui.QLabel(self.centralwidget)
self.funkcja_label.setGeometry(QtCore.QRect(70, 30, 161, 21))
self.funkcja_label.setObjectName(_fromUtf8("funkcja_label"))
self.amplituda_label = QtGui.QLabel(self.centralwidget)
self.amplituda_label.setGeometry(QtCore.QRect(70, 60, 61, 21))
self.amplituda_label.setObjectName(_fromUtf8("amplituda_label"))
self.spinbox_amp = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_amp.setGeometry(QtCore.QRect(190, 60, 62, 22))
self.spinbox_amp.setObjectName(_fromUtf8("spinbox_amp"))
self.czestotliwosc_label = QtGui.QLabel(self.centralwidget)
self.czestotliwosc_label.setGeometry(QtCore.QRect(70, 90, 70, 21))
self.czestotliwosc_label.setObjectName(
_fromUtf8("czestotliwosc_label"))
self.spinbox_freq = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_freq.setGeometry(QtCore.QRect(190, 90, 62, 22))
self.spinbox_freq.setObjectName(_fromUtf8("spinbox_freq"))
self.przesuniecie_label = QtGui.QLabel(self.centralwidget)
self.przesuniecie_label.setGeometry(QtCore.QRect(70, 120, 61, 21))
self.przesuniecie_label.setObjectName(_fromUtf8("przesuniecie_label"))
self.spinbox_przesuniecie = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_przesuniecie.setGeometry(QtCore.QRect(190, 120, 62, 22))
self.spinbox_przesuniecie.setObjectName(
_fromUtf8("spinbox_przesuniecie"))
self.checkBox_poczatkowa = QtGui.QCheckBox(self.centralwidget)
self.checkBox_poczatkowa.setGeometry(QtCore.QRect(70, 330, 131, 21))
self.checkBox_poczatkowa.setChecked(True)
self.checkBox_poczatkowa.setObjectName(
_fromUtf8("checkBox_poczatkowa"))
self.checkBox_dopasowana = QtGui.QCheckBox(self.centralwidget)
self.checkBox_dopasowana.setGeometry(QtCore.QRect(70, 350, 131, 21))
self.checkBox_dopasowana.setChecked(True)
self.checkBox_dopasowana.setObjectName(
_fromUtf8("checkBox_dopasowana"))
self.checkBox_dane = QtGui.QCheckBox(self.centralwidget)
self.checkBox_dane.setGeometry(QtCore.QRect(70, 370, 131, 21))
self.checkBox_dane.setChecked(True)
self.checkBox_dane.setObjectName(_fromUtf8("checkBox_dane"))
self.rysuj_label = QtGui.QLabel(self.centralwidget)
self.rysuj_label.setGeometry(QtCore.QRect(70, 310, 161, 21))
self.rysuj_label.setObjectName(_fromUtf8("rysuj_label"))
self.rysuj_button = QtGui.QPushButton(self.centralwidget)
self.rysuj_button.setGeometry(QtCore.QRect(160, 400, 75, 23))
self.rysuj_button.setObjectName(_fromUtf8("rysuj_button"))
self.dopasowane_label = QtGui.QLabel(self.centralwidget)
self.dopasowane_label.setGeometry(QtCore.QRect(350, 400, 111, 21))
self.dopasowane_label.setObjectName(_fromUtf8("dopasowane_label"))
self.amp_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.amp_dopasowane_label.setGeometry(QtCore.QRect(350, 420, 61, 21))
self.amp_dopasowane_label.setObjectName(
_fromUtf8("amp_dopasowane_label"))
self.freq_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.freq_dopasowane_label.setGeometry(QtCore.QRect(350, 440, 70, 21))
self.freq_dopasowane_label.setObjectName(
_fromUtf8("freq_dopasowane_label"))
self.przez_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.przez_dopasowane_label.setGeometry(QtCore.QRect(350, 460, 61, 21))
self.przez_dopasowane_label.setObjectName(
_fromUtf8("przez_dopasowane_label"))
self.chi_label = QtGui.QLabel(self.centralwidget)
self.chi_label.setGeometry(QtCore.QRect(610, 420, 61, 21))
self.chi_label.setObjectName(_fromUtf8("chi_label"))
self.amp_value = QtGui.QLabel(self.centralwidget)
self.amp_value.setGeometry(QtCore.QRect(470, 420, 111, 21))
self.amp_value.setObjectName(_fromUtf8("amp_value"))
self.freq_value = QtGui.QLabel(self.centralwidget)
self.freq_value.setGeometry(QtCore.QRect(470, 440, 111, 21))
self.freq_value.setObjectName(_fromUtf8("freq_value"))
self.przes_value = QtGui.QLabel(self.centralwidget)
self.przes_value.setGeometry(QtCore.QRect(470, 460, 111, 21))
self.przes_value.setObjectName(_fromUtf8("przes_value"))
self.chi_value = QtGui.QLabel(self.centralwidget)
self.chi_value.setGeometry(QtCore.QRect(690, 420, 101, 21))
self.chi_value.setObjectName(_fromUtf8("chi_value"))
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.spinbox_amp.setMaximum(10)
self.spinbox_amp.setMinimum(0.1)
self.spinbox_freq.setMaximum(10)
self.spinbox_ilePkt.setMaximum(10000)
self.spinbox_ilePkt.setMinimum(100)
self.spinbox_przesuniecie.setMinimum(1)
self.spinbox_przesuniecie.setMaximum(10)
self.rysuj_button.clicked.connect(self.start)
self.initSpinBox()
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "Fitter", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
_translate("MainWindow", "Wykres", None))
self.iloscPkt_label.setText(
_translate("MainWindow", "Ilosc punktow", None))
self.rozrzutPkt_label.setText(
_translate("MainWindow", "Rozrzut punktow", None))
self.zakresOd_label.setText(
_translate("MainWindow", "Zakres x od", None))
self.zakresDo_label.setText(_translate("MainWindow", "do", None))
self.rozklad_label.setText(
_translate("MainWindow", "<b>Rozklad punktow:</b>", None))
self.funkcja_label.setText(
_translate("MainWindow", "<b>Funkcja: sinus</b>", None))
self.amplituda_label.setText(
_translate("MainWindow", "Amplituda:", None))
self.czestotliwosc_label.setText(
_translate("MainWindow", "Czestotliwosc:", None))
self.przesuniecie_label.setText(
_translate("MainWindow", "Przesuniecie:", None))
self.checkBox_poczatkowa.setText(
_translate("MainWindow", "Funkcja poczatkowa", None))
self.checkBox_dopasowana.setText(
_translate("MainWindow", "Funkcja dopasowana", None))
self.checkBox_dane.setText(_translate("MainWindow", "Dane", None))
self.rysuj_label.setText(
_translate("MainWindow", "<b>Rysuj na wykresie:</b>", None))
self.rysuj_button.setText(_translate("MainWindow", "Rysuj", None))
self.dopasowane_label.setText(
_translate("MainWindow", "<b>Dopasowane dane:</b>", None))
self.amp_dopasowane_label.setText(
_translate("MainWindow", "Amplituda:", None))
self.freq_dopasowane_label.setText(
_translate("MainWindow", "Czestotliwosc:", None))
self.przez_dopasowane_label.setText(
_translate("MainWindow", "Przesuniecie:", None))
self.chi_label.setText(_translate("MainWindow", "Chi square:", None))
self.amp_value.setText(_translate("MainWindow", "x", None))
self.freq_value.setText(_translate("MainWindow", "x", None))
self.przes_value.setText(_translate("MainWindow", "x", None))
self.chi_value.setText(_translate("MainWindow", "x", None))
def testSimple1(self, plot=False):
print("====testEvidence for Gauss (Simple) ====")
np.random.seed(2345)
nn = 100
x = np.arange(nn, dtype=int) // 20
# ym = np.linspace( 1.0, 2.0, nn )
ym = 1.5
nf = 0.1
noise = np.random.normal(0.0, 1.0, nn)
y = ym + nf * noise
pm = PolynomialModel(0)
print(pm.npchain)
bf = Fitter(x, pm, fixedScale=nf)
pars = bf.fit(y)
print("pars ", pars)
yfit = pm.result(x, pars)
std = bf.stdevs
print("stdv ", std)
print("chisq %f scale %f sumwgt %f" %
(bf.chisq, bf.scale, bf.sumwgt))
print(bf.chiSquared(y, pars))
lo = 1.40
hi = 1.60
logz = bf.getLogZ(limits=[lo, hi])
maxloglik = bf.logLikelihood
lintpr = math.log(hi - lo)
errdis = GaussErrorDistribution(x, y, scale=nf)
npt = 401
p0 = np.linspace(lo, hi, npt)
for i in range(pm.npchain):
L0 = np.ndarray(npt, dtype=float)
pp = np.append(pars, [nf])
for k, p in enumerate(p0):
pp[i] = p
L0[k] = errdis.logLikelihood(pm, pp)
lz = np.log(np.sum(np.exp(L0)) * (hi - lo) / npt)
maxl = np.max(L0)
L0 -= maxloglik
if plot:
gm = GaussModel()
gm.parameters = [1.0, pars[i], std[i]]
plt.plot(p0, gm(p0), 'b-')
plt.plot(p0, np.exp(L0), 'k-')
print("BF logL ", maxloglik, bf.logOccam, maxl, np.exp(maxl), lintpr)
print("ED logL ", errdis.logLikelihood(pm, np.append(pars, [nf])))
print(
"evid %f %f %f" %
(logz, lz - lintpr, maxloglik + math.log(0.01 * math.pi) - lintpr))
# print( "evid %f %f %f"%( logz, lz, maxloglik + math.log( 0.01 * math.pi ) ) )
if plot:
plt.show()
for q, h in enumerate(histos_qcd):
print "************ Found", h.GetEntries(
), "background events for quantile", quantiles[q]
print "TOTAL SIGNAL EVENTS", histos_sig[-1].GetEntries()
print "TOTAL BACKGROUND EVENTS", histos_qcd[-1].GetEntries()
print
################################### NOW MAKE THE FITS ###################################
cmdCombine = 'combineCards.py '
for iq, q in enumerate(quantiles):
print "########## FIT SIGNAL AND SAVE PARAMETERS ############"
sig_outfile = ROOT.TFile("sig_fit_%s.root" % q, "RECREATE")
fitter = Fitter(['mjj_fine'])
fitter.signalResonance('model_s', "mjj_fine", mass)
fitter.w.var("MH").setVal(mass)
fitter.importBinnedData(histos_sig[iq], ['mjj_fine'], 'data')
fres = fitter.fit('model_s', 'data', [ROOT.RooFit.Save(1)])
fres.Print()
mjj_fine = fitter.getVar('mjj_fine')
mjj_fine.setBins(len(bins_sig_fit))
chi2_fine = fitter.projection("model_s", "data", "mjj_fine",
"signal_fit_%s.png" % q)
fitter.projection("model_s", "data", "mjj_fine",
"signal_fit_%s_log.png" % q, 0, True)
chi2 = fitter.projection("model_s", "data", "mjj_fine",
"signal_fit_%s_binned.png" % q,
roobins_sig_fit)
def test1( self, plot=False ):
""" # test slope fit """
print( "\n Robust fitter Test 1 \n" )
ndata = 101
aa = 5.0 # average offset
bb = 2.0 # slope
ss = 0.3 # noise Normal distr.
x = numpy.linspace( -1, +1, ndata, dtype=float )
numpy.random.seed( 12345 )
y = aa + bb * x + ss * numpy.random.randn( ndata )
model = PolynomialModel( 1 )
fitter = Fitter( x, model )
print( "Testing Straight Line fit" )
par = fitter.fit( y )
std = fitter.stdevs
chisq = fitter.chisq
print( "truth " + fmt( aa ) + fmt( bb ) )
print( "params " + fmt( par ) )
print( "stdevs " + fmt( std ) )
print( "chisq " + fmt( chisq ) )
assertAAE( par, numpy.asarray( [aa, bb] ), 2 )
if plot :
plt.plot( x, y, 'k.' )
plt.plot( x, model( x ), 'k-' )
# make some outliers
ko = [10*k+4 for k in range( 10 )]
ko = numpy.asarray( ko )
y[ko] += numpy.linspace( -5, 2, 10 )
romod = PolynomialModel( 1 )
altfit = Fitter( x, romod )
alt = altfit.fit( y )
ast = altfit.stdevs
altch = altfit.chisq
print( "params " + fmt( alt ) )
print( "stdevs " + fmt( ast ) )
print( "chisq " + fmt( altch ) )
if plot :
plt.plot( x, romod( x ), 'b-' )
rf = RobustShell( altfit )
Tools.printclass( rf )
alt = rf.fit( y )
ast = altfit.stdevs
altch = altfit.chisq
print( rf )
print( "params " + fmt( alt ) )
print( "stdevs " + fmt( ast ) )
print( "chisq " + fmt( altch ) + fmt( rf.scale ) )
print( "weight " + fmt( rf.weights[ko], max=None ) )
if plot :
plt.plot( x, romod( x ), 'g-' )
plt.plot( x, rf.weights, 'g-' )
assertAAE( par, alt, 1 )
assertAAE( std, ast, 1 )
rf = RobustShell( altfit, kernel=Cosine(), domain=4.0 )
alt = rf.fit( y )
ast = altfit.stdevs
altch = altfit.chisq
print( rf )
print( "params " + fmt( alt ) )
print( "stdevs " + fmt( ast ) )
print( "chisq " + fmt( altch ) + fmt( rf.scale ) )
print( "weight " + fmt( rf.weights[ko], max=None ) )
if plot :
plt.plot( x, romod( x ), 'r-' )
plt.plot( x, rf.weights, 'r-' )
assertAAE( par, alt, 1 )
assertAAE( std, ast, 1 )
rf = RobustShell( altfit, kernel=Huber, domain=1.0 )
# rf.setNoiseScale( 0.3 )
alt = rf.fit( y )
ast = altfit.stdevs
altch = altfit.chisq
print( rf )
print( "params " + fmt( alt ) )
print( "stdevs " + fmt( ast ) )
print( "chisq " + fmt( altch ) + fmt( rf.scale ) )
print( "weight " + fmt( rf.weights[ko], max=None ) )
if plot :
plt.plot( x, romod( x ), 'c-' )
plt.plot( x, rf.weights, 'c-' )
assertAAE( par, alt, 1 )
assertAAE( std, ast, 1 )
rf = RobustShell( altfit, kernel=Uniform )
alt = rf.fit( y )
ast = altfit.stdevs
altch = altfit.chisq
print( rf )
print( "params " + fmt( alt ) )
print( "stdevs " + fmt( ast ) )
print( "chisq " + fmt( altch ) + fmt( rf.scale ) )
print( "weight " + fmt( rf.weights[ko], max=None ) )
if plot :
plt.plot( x, romod( x ), 'm-' )
plt.plot( x, rf.weights, 'm-' )
assertAAE( par, alt, 1 )
assertAAE( std, ast, 1 )
('DY+jets', 'dy.root'),
('single top', 'single_top.root'),
('TTbar', 'ttbar.root'),
('W+jets', 'wjets.root'),
])
else:
datasets = OrderedDict([
('TTbar', 'ttbar.root'),
])
event_options = {'JEC': 'nominal', 'muon_isolation': 0.1}
analyzers = OrderedDict()
for name, file_name in datasets.iteritems():
analyzer = TTbarAnalyzer(name, file_name, event_options)
# run analysis for dataset
analyzer.run()
analyzers[name] = analyzer
plotter = Plotter(analyzers)
plotter.process()
## fitting the top mass ##
if run_all:
fitter = Fitter(analyzers['Data'])
fitter.fit(130., 210.)
# fitter.fit(x,y)
# (x,y) = fit range
else:
fitter = Fitter(analyzers['TTbar'])
fitter.fit(130., 210.)
def stdFittertest(myfitter,
npt,
xmin=-10.0,
xmax=10.0,
noise=0.1,
plot=False,
map=False,
keep=None,
errdis=None,
scale=None,
power=2.0,
options={}):
numpy.set_printoptions(precision=3, suppress=True)
tc = unittest.TestCase()
## make data
x = numpy.linspace(xmin, xmax, npt, dtype=float)
m = SincModel()
p = [3.0, 1.0, 2.0]
ym = m.result(x, p)
numpy.random.seed(5753258)
y = ym + noise * numpy.random.randn(npt)
knots = numpy.linspace(xmin, xmax, 13, dtype=float)
lmdl = BSplinesModel(knots)
lftr = Fitter(x, lmdl)
lpar = lftr.fit(y)
lchi = lftr.chisq
lfit = lmdl(x)
mdl = BSplinesModel(knots)
ftr = myfitter(x,
mdl,
map=map,
keep=keep,
errdis=errdis,
scale=scale,
power=power)
print("############### Test ", ftr,
' ###################################')
par = ftr.fit(y, **options)
chi = ftr.chisq
yfit = mdl(x)
print("lpar ", fmt(lpar, indent=4))
print("lstd ", fmt(lftr.stdevs, indent=4))
print("lchi ", fmt(lchi), " scale ", fmt(lftr.scale))
print("par ", fmt(par, indent=4))
print("std ", fmt(ftr.stdevs, indent=4))
print("chi ", fmt(chi), " scale ", fmt(ftr.scale), " iter ",
fmt(ftr.iter))
lmce = ftr.monteCarloError(x)
# tc.assertTrue( abs( lchi - chi ) < noise )
# tc.assertTrue( numpy.all( numpy.abs( yfit - lfit ) < 2 * lmce ) )
if plot:
plt.figure(str(ftr))
plt.plot(x, ym, 'k-')
plt.plot(x, y, 'k*')
plt.plot(x, lfit, 'g-')
plt.plot(x, yfit, 'r-')
plt.plot(x, yfit - lmce, 'm-')
plt.plot(x, yfit + lmce, 'm-')
def testStraightLineParameter(self, plot=False):
"""
test slope fit
1. Compare PolynomialModel(1) with chain of PowerModel(0) + PowerModel(1)
2. Fix parameters in PolynomialModel
"""
print("\n Fitter Test 1 \n")
model = PolynomialModel(1)
fitter = Fitter(self.x, model)
model0 = PowerModel(0)
model1 = PowerModel(1)
model0.addModel(model1)
altfit = Fitter(self.x, model0)
y = self.noise + self.aa + self.bb * self.x
print("Testing Straight Line fit")
self.assertTrue(model1.npchain == 2)
par = fitter.fit(y)
alt = altfit.fit(y)
print("offst = %f alt = %f truth = %f" % (par[0], alt[0], self.aa))
print("slope = %f alt = %f truth = %f" % (par[1], alt[1], self.bb))
assertAAE(par, alt)
chisq = fitter.chisq
altch = altfit.chisq
print("chisq = %f alt = %f" % (chisq, altch))
self.assertTrue(self.eq(chisq, altch))
std = fitter.standardDeviations
ast = altfit.standardDeviations
print("stdev = %f alt = %f" % (std[0], ast[0]))
print("stdev = %f alt = %f" % (std[1], ast[1]))
assertAAE(std, ast)
par1 = altfit.fit(y, keep={0: par[0]})
if plot:
FitPlot.plotFit(self.x, y, model0, residuals=True)
self.assertTrue(2 == len(par1))
assertAAE(par1, par)
self.assertTrue(model0.npchain == 2)
model1 = PolynomialModel(2, fixed={2: 0.0})
altfit = Fitter(self.x, model1)
par1 = altfit.fit(y)
print(par, par1)
if plot:
FitPlot.plotFit(self.x, y, model0)
self.assertTrue(2 == len(par1))
assertAAE(par, par)
error1 = altfit.monteCarloError()
print("error = ", error1)
def func(x, a, b, c):
return a*x**b + c
if int(raw_input("sin -1, weird function -2\n")) == 1:
gen_func = math.sin
p0 =[]
p1 = [1, 1, 1, 1]
fit_func = my_sin
else:
gen_func = func
print "dziwne rownanie a*x^b + c"
p0 = [float(raw_input("podaj wps. a\n")), float(raw_input("podaj wps. b\n")), float(raw_input("podaj wps. c\n"))]
fit_func = func
p1 = [1, 1, 1]
data_points = generator.generate_data_points(gen_func, p0)
fit_data_y = Fitter.fit(fit_func, data_points, p1)
fit_data = [data_points[0], fit_data_y]
chi, nchi = StatAnalyser.chi2(data_points[1], fit_data_y, len(p1))
print "wartosc testu chi^2: ", chi, "znormalizowana wartosc chi: ", nchi, "\n"
plot = Plotter()
plot.plot_data_points(data_points)
plot.plot_fit_curve(fit_data)
plot.show_plot()
print "############# FIT BACKGROUND AND SAVE PARAMETERS ###########"
chi2s = [0] * len(nParsToTry)
ndofs = [0] * len(nParsToTry)
probs = [0] * len(nParsToTry)
fitters_QCD = [None] * len(nParsToTry)
qcd_fnames = [""] * len(nParsToTry)
regions = [("SB1", binsx[0], sb1_edge), ("SB2", sb2_edge, binsx[-1]),
("FULL", binsx[0], binsx[-1])]
for i, nPars in enumerate(nParsToTry):
print("Trying %i parameter background fit" % nPars)
qcd_fnames[i] = str(nPars) + 'par_qcd_fit.root'
qcd_outfile = ROOT.TFile(qcd_fnames[i], 'RECREATE')
fitter_QCD = Fitter(['mjj_fine'])
fitter_QCD.qcdShape('model_b', 'mjj_fine', nPars)
fitter_QCD.importBinnedData(histos_sb, ['mjj_fine'],
'data_qcd',
regions=regions)
fres = fitter_QCD.fit('model_b', 'data_qcd', [
ROOT.RooFit.Save(1),
ROOT.RooFit.Verbose(0),
ROOT.RooFit.Range("SB1,SB2")
])
#fres.Print()
chi2_fine = fitter_QCD.projection(
"model_b", "data_qcd", "mjj_fine",
plot_dir + str(nPars) + "par_qcd_fit.png", 0, True)
#chi2_binned = fitter_QCD.projection("model_b","data_qcd","mjj_fine",plot_dir + str(nPars) + "par_qcd_fit_binned.png",roobins,True)
zak = float(raw_input("Wprowadz wartosc zaklocen\n"))
am = float(raw_input("Wprowadz amplitude\n"))
przes = float(raw_input("Wprowadz przesuniecie\n"))
d.setData(przes, okr, pom_okr, am, zak)
break
except ValueError:
print 'Wprowadzono niepoprawne dane - sprobuj jeszcze raz \n'
elif (std == str(1)):
break
if (d.getNoise() >= 2.5):
print 'Uwaga! Wybrano wartosc zaklocen: ' + str(
d.getNoise()) + '. Moze to spowodowac bledy rozwiazania'
#storage = d.getData()
data = d.generateData(math.sin)
f = Fitter()
fit_data = f.fit(sin, data, [1])
fit = [data[0], fit_data]
chi = StatAnalyser.chi2(data[1], fit_data)
chi_norm = StatAnalyser.chi2Norm(chi, data[1])
print 'Test Pearsona (chi^2) = ' + str(
chi) + ' wartosc chi2 znormalizowana: ' + str(chi_norm)
plot = Plotter()
plot.make_plot(data)
plot.make_plot([data[0], sin(data[0], d.getAmp())], 'fun')
plot.make_plot(fit, 'fit')
plot.draw_plot()
print '**********************************************************************'
def testWeights1(self, plot=None):
print("====testWeights 1====================")
nn = 5
x = np.arange(nn, dtype=float)
y = x % 2
y[2] = 0.5
x4 = np.arange(4 * nn, dtype=float)
y4 = x4 % 2
y4[range(2, 20, 5)] = 0.5
pm = PolynomialModel(0)
bf = Fitter(x, pm)
pars = bf.fit(y)
var = bf.makeVariance()
print("======= 5 data points; no weights; no noiseScale ===")
print("pars ", pm.parameters, "stdv ", bf.stdevs, bf.hessian,
bf.covariance, var)
print("chisq %f scale %f %f sumwgt %f" %
(bf.chisq, bf.scale, bf.makeVariance(), bf.sumwgt))
pm = PolynomialModel(0)
bf = Fitter(x4, pm)
pars = bf.fit(y4)
print("======= 20 data points; no weights; no noiseScale ===")
print("pars ", pm.parameters, "stdv ", bf.stdevs, bf.hessian,
bf.covariance)
print("chisq %f scale %f %f sumwgt %f" %
(bf.chisq, bf.scale, bf.makeVariance(), bf.sumwgt))
print("======= 5 data points; weights = 4; no noiseScale ===")
pm = PolynomialModel(0)
bf = Fitter(x, pm)
w = np.zeros(nn, dtype=float) + 4
pars = bf.fit(y, w)
print("pars ", pm.parameters, "stdv ", bf.stdevs, bf.hessian,
bf.covariance)
print("chisq %f scale %f %f sumwgt %f" %
(bf.chisq, bf.scale, bf.makeVariance(), bf.sumwgt))
pm = PolynomialModel(0)
bf = Fitter(x, pm)
pars = bf.fit(y)
print("======= 5 data points; no weights; noiseScale ===")
print("pars ", pm.parameters, "stdv ", bf.stdevs, bf.hessian,
bf.covariance)
print("chisq %f scale %f %f sumwgt %f" %
(bf.chisq, bf.scale, bf.makeVariance(), bf.sumwgt))
print("noise ", bf.scale, " +- ", bf.stdevScale, " keep ", bf.keep)
"""
directory = network_name + '/'
# if os.path.isdir(directory):
# shutil.rmtree(directory)
if not os.path.isdir(directory):
os.mkdir(directory)
print("Network name: {}".format(network_name))
print("Input edge file: {}".format(args.file))
# print("Sampling proportion step: {}".format(args.step))
# print("Number of samples for each sampling proportion: {}".format(args.t))
# print("Embedding Method: {}".format(args.embedding))
print("Sampling Method: {}".format(args.sampling))
# print("Fitting Method: {}".format(args.fitting))
sampler = Sampler(args)
sampler.sample()
# Embedding with graph2vec
embedder = Embedder(args)
points = embedder.embed()
fitter = Fitter(args)
fitter.fit(points)
# Embedding with kron
args.embedding = 'kroneckerPoint'
embedder = Embedder(args)
points = embedder.embed()
fitter = Fitter(args)
fitter.fit(points)
def testEvidence(self, plot=None):
print("====testEvidence======================")
nn = 100
x = np.arange(nn, dtype=float) / (nn / 2) - 1
ym = 1.2 + 0.5 * x
nf = 0.1
noise = np.random.randn(nn)
y = ym + nf * noise
pm = PolynomialModel(1)
bf = Fitter(x, pm)
w = np.ones(nn, dtype=float)
pars = bf.fit(y, w)
print("pars ", pars)
yfit = pm.result(x, pars)
print("stdv ", bf.getStandardDeviations())
bf.getHessian()
bf.chiSquared(y, weights=w)
print("chisq %f scale %f sumwgt %f" %
(bf.chisq, bf.getScale(), bf.sumwgt))
lolim = [-100.0, -100.0]
hilim = [+100.0, +100.0]
nslim = [0.01, 100.0]
print("=== Evidence for Parameters only; fixedScale is not set")
print(
"evid %f occam %f lhood %f fixedScale=" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam, bf.logLikelihood),
bf.fixedScale)
if plot:
plt.plot(x, ym, 'g.')
plt.plot(x, y, 'b+')
plt.plot(x, yfit, 'r-')
plt.show()
print("=== Evidence for Parameters and scale; fixedScale not set")
print(
"evid %f occam %f lhood %f fixedScale=" %
(bf.getLogZ(limits=[lolim, hilim],
noiseLimits=nslim), bf.logOccam, bf.logLikelihood),
bf.fixedScale)
# self.assertRaises( ValueError, bf.getLogZ() )
# self.assertRaises( ValueError, bf.logOccam )
# self.assertRaises( ValueError, bf.logLikelihood )
print("=== Evidence for Parameters and scale; fixedScale=10")
bf.fixedScale = 10.0
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim], noiseLimits=nslim),
bf.logOccam, bf.logLikelihood, bf.fixedScale))
print("=== Evidence for Parameters, fixed scale = 1")
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam,
bf.logLikelihood, bf.fixedScale))
print("=== Evidence for Parameters and fixed scale = 0.01")
bf.fixedScale = 0.01
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam,
bf.logLikelihood, bf.fixedScale))
print("=== Evidence for Parameters and fixed scale = 0.1")
bf.fixedScale = 0.1
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam,
bf.logLikelihood, bf.fixedScale))
print("=== Evidence for Parameters and fixed scale = 1.0")
bf.fixedScale = 1.0
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam,
bf.logLikelihood, bf.fixedScale))
print("=== Evidence for Parameters and fixed scale = 10.0")
bf.fixedScale = 10.0
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(limits=[lolim, hilim]), bf.logOccam,
bf.logLikelihood, bf.fixedScale))
pm.setLimits(lolim, hilim)
print("limits par[0] ", pm.priors[0].lowLimit, pm.priors[0].highLimit)
print("limits par[1] ", pm.priors[1].lowLimit, pm.priors[1].highLimit)
print("=== Evidence for Parameters and fixed scale = 10.0")
bf.fixedScale = 10.0
print("evid %f occam %f lhood %f fixeScale=%f" %
(bf.getLogZ(), bf.logOccam, bf.logLikelihood, bf.fixedScale))
class Ui_MainWindow(QtGui.QMainWindow):
def __init__(self):
plott = Plotter()
QtGui.QMainWindow.__init__(self)
self.setWindowIcon(QtGui.QIcon('phyton.ico'))
self.setupUi(self)
self.fit = Fitter()
self.gen = Generator()
self.plot = Plotter()
self.fitted_args = []
self.chi2 = None
self.chi2Error = 0.5
#Funkcja odpowiedzialna za wywolanie funkcji tworzacej nowy wykres z klasy Plotter
#oraz wstawienie go w GUI
def DrawPlot(self):
Plotter.dopasowana = self.checkBox_dopasowana.isChecked()
Plotter.poczatkowa = self.checkBox_poczatkowa.isChecked()
Plotter.dane = self.checkBox_dane.isChecked()
Plotter.xlim_min = self.spinbox_zakresOd.value()
Plotter.xlim_max = self.spinbox_zakresDo.value()
self.tabWidget.removeTab(0)
self.newTab = QtGui.QWidget()
self.newTab.setObjectName(_fromUtf8("plot"))
self.tabWidget.insertTab(0,self.newTab, _fromUtf8("Wykres"))
self.tabWidget.setCurrentWidget(self.newTab)
layout = QtGui.QVBoxLayout()
fig = self.plot.plot(self.gen.returnX(),self.gen.returnY(),self.gen.returnYn(),self.fit.returnFittedData())
layout.addWidget(FigureCanvasQTAgg(fig))
self.newTab.setLayout(layout)
print 'Plot created.'
#Funkcja uruchamiana po uzyciu przycisku generujacego wykres w GUI
#Odpowiedzialna za kolejne uruchomienie wszystkich funkcje z zaimportowanych klas
def start(self):
print 'Generating data...'
#przekazanie danych ze spinboxow (z interfejsu) do generatora danych
self.gen.getData(self.spinbox_amp.value(),self.spinbox_freq.value(),self.spinbox_ilePkt.value(),self.spinbox_rozrzut.value(),self.spinbox_przesuniecie.value(),self.spinbox_zakresOd.value(),self.spinbox_zakresDo.value())
# #uruchamianie kreatora
self.gen.creator()
#przekazywanie danych do fittera
self.fit.getData(self.gen.returnX(),self.gen.returnYn())
chio = None
oneMoreGuess = 0
#iteracyjne poszukiwanie odpowiedniej czestotliwosci, dobierane na podstawie porownania z wartoscia chi2
print "Fitting..."
while ((chio == None) or (chio > self.chi2Error)) and (oneMoreGuess < self.spinbox_freq.maximum()):
#dopasowywanie funkcji
self.fit.fit(self.fit.guess(oneMoreGuess))
chio = Stats.chi(self.gen.returnY(),self.fit.returnFittedData())
oneMoreGuess += 0.1
self.chi2 = chio
if self.chi2 <= self.chi2Error:
print 'Fitting status: OK'
else:
print 'Fitting status: Failure'
#wydrukowanie zfitowanych wartosci
self.fitted_args = self.fit.printfitted_args()
#tworzenie plottera
print 'Drawing plot...'
self.DrawPlot()
#aktualizacja GUI
self.UpdateGui()
print 'All done.'
print '-----------------'
#Funkcja akutalizujaca informacje w gui
def UpdateGui(self):
self.chi_value.setText(str(round(self.chi2,6)))
self.amp_value.setText(str(round(self.fitted_args[0],6)))
self.freq_value.setText(str(round(self.fitted_args[1],6)))
self.przes_value.setText(str(round(self.fitted_args[2],6)))
#Funkcja inicjalizujaca spinboxy
def initSpinBox(self):
self.spinbox_amp.setValue(1)
self.spinbox_freq.setValue(1)
self.spinbox_rozrzut.setValue(0.1)
self.spinbox_ilePkt.setValue(500)
self.spinbox_zakresOd.setValue(0)
self.spinbox_zakresDo.setValue(10)
self.spinbox_przesuniecie.setValue(0)
#Funkcje odpowiedzialne za tworzenie GUI
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.setFixedSize(914, 523)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.tabWidget = QtGui.QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(QtCore.QRect(350, 30, 531, 371))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tab = QtGui.QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
self.spinbox_rozrzut = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_rozrzut.setGeometry(QtCore.QRect(190, 230, 62, 22))
self.spinbox_rozrzut.setObjectName(_fromUtf8("spinbox_rozrzut"))
self.iloscPkt_label = QtGui.QLabel(self.centralwidget)
self.iloscPkt_label.setGeometry(QtCore.QRect(70, 200, 81, 21))
self.iloscPkt_label.setObjectName(_fromUtf8("iloscPkt_label"))
self.rozrzutPkt_label = QtGui.QLabel(self.centralwidget)
self.rozrzutPkt_label.setGeometry(QtCore.QRect(70, 230, 101, 21))
self.rozrzutPkt_label.setObjectName(_fromUtf8("rozrzutPkt_label"))
self.zakresOd_label = QtGui.QLabel(self.centralwidget)
self.zakresOd_label.setGeometry(QtCore.QRect(70, 260, 71, 21))
self.zakresOd_label.setObjectName(_fromUtf8("zakresOd_label"))
self.zakresDo_label = QtGui.QLabel(self.centralwidget)
self.zakresDo_label.setGeometry(QtCore.QRect(230, 260, 21, 21))
self.zakresDo_label.setObjectName(_fromUtf8("zakresDo_label"))
self.spinbox_zakresOd = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_zakresOd.setGeometry(QtCore.QRect(160, 260, 62, 22))
self.spinbox_zakresOd.setObjectName(_fromUtf8("spinbox_zakresOd"))
self.spinbox_zakresDo = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_zakresDo.setGeometry(QtCore.QRect(250, 260, 62, 22))
self.spinbox_zakresDo.setObjectName(_fromUtf8("spinbox_zakresDo"))
self.spinbox_ilePkt = QtGui.QSpinBox(self.centralwidget)
self.spinbox_ilePkt.setGeometry(QtCore.QRect(190, 200, 61, 22))
self.spinbox_ilePkt.setObjectName(_fromUtf8("spinbox_ilePkt"))
self.rozklad_label = QtGui.QLabel(self.centralwidget)
self.rozklad_label.setGeometry(QtCore.QRect(70, 170, 161, 21))
self.rozklad_label.setObjectName(_fromUtf8("rozklad_label"))
self.funkcja_label = QtGui.QLabel(self.centralwidget)
self.funkcja_label.setGeometry(QtCore.QRect(70, 30, 161, 21))
self.funkcja_label.setObjectName(_fromUtf8("funkcja_label"))
self.amplituda_label = QtGui.QLabel(self.centralwidget)
self.amplituda_label.setGeometry(QtCore.QRect(70, 60, 61, 21))
self.amplituda_label.setObjectName(_fromUtf8("amplituda_label"))
self.spinbox_amp = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_amp.setGeometry(QtCore.QRect(190, 60, 62, 22))
self.spinbox_amp.setObjectName(_fromUtf8("spinbox_amp"))
self.czestotliwosc_label = QtGui.QLabel(self.centralwidget)
self.czestotliwosc_label.setGeometry(QtCore.QRect(70, 90, 70, 21))
self.czestotliwosc_label.setObjectName(_fromUtf8("czestotliwosc_label"))
self.spinbox_freq = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_freq.setGeometry(QtCore.QRect(190, 90, 62, 22))
self.spinbox_freq.setObjectName(_fromUtf8("spinbox_freq"))
self.przesuniecie_label = QtGui.QLabel(self.centralwidget)
self.przesuniecie_label.setGeometry(QtCore.QRect(70, 120, 61, 21))
self.przesuniecie_label.setObjectName(_fromUtf8("przesuniecie_label"))
self.spinbox_przesuniecie = QtGui.QDoubleSpinBox(self.centralwidget)
self.spinbox_przesuniecie.setGeometry(QtCore.QRect(190, 120, 62, 22))
self.spinbox_przesuniecie.setObjectName(_fromUtf8("spinbox_przesuniecie"))
self.checkBox_poczatkowa = QtGui.QCheckBox(self.centralwidget)
self.checkBox_poczatkowa.setGeometry(QtCore.QRect(70, 330, 131, 21))
self.checkBox_poczatkowa.setChecked(True)
self.checkBox_poczatkowa.setObjectName(_fromUtf8("checkBox_poczatkowa"))
self.checkBox_dopasowana = QtGui.QCheckBox(self.centralwidget)
self.checkBox_dopasowana.setGeometry(QtCore.QRect(70, 350, 131, 21))
self.checkBox_dopasowana.setChecked(True)
self.checkBox_dopasowana.setObjectName(_fromUtf8("checkBox_dopasowana"))
self.checkBox_dane = QtGui.QCheckBox(self.centralwidget)
self.checkBox_dane.setGeometry(QtCore.QRect(70, 370, 131, 21))
self.checkBox_dane.setChecked(True)
self.checkBox_dane.setObjectName(_fromUtf8("checkBox_dane"))
self.rysuj_label = QtGui.QLabel(self.centralwidget)
self.rysuj_label.setGeometry(QtCore.QRect(70, 310, 161, 21))
self.rysuj_label.setObjectName(_fromUtf8("rysuj_label"))
self.rysuj_button = QtGui.QPushButton(self.centralwidget)
self.rysuj_button.setGeometry(QtCore.QRect(160, 400, 75, 23))
self.rysuj_button.setObjectName(_fromUtf8("rysuj_button"))
self.dopasowane_label = QtGui.QLabel(self.centralwidget)
self.dopasowane_label.setGeometry(QtCore.QRect(350, 400, 111, 21))
self.dopasowane_label.setObjectName(_fromUtf8("dopasowane_label"))
self.amp_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.amp_dopasowane_label.setGeometry(QtCore.QRect(350, 420, 61, 21))
self.amp_dopasowane_label.setObjectName(_fromUtf8("amp_dopasowane_label"))
self.freq_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.freq_dopasowane_label.setGeometry(QtCore.QRect(350, 440, 70, 21))
self.freq_dopasowane_label.setObjectName(_fromUtf8("freq_dopasowane_label"))
self.przez_dopasowane_label = QtGui.QLabel(self.centralwidget)
self.przez_dopasowane_label.setGeometry(QtCore.QRect(350, 460, 61, 21))
self.przez_dopasowane_label.setObjectName(_fromUtf8("przez_dopasowane_label"))
self.chi_label = QtGui.QLabel(self.centralwidget)
self.chi_label.setGeometry(QtCore.QRect(610, 420, 61, 21))
self.chi_label.setObjectName(_fromUtf8("chi_label"))
self.amp_value = QtGui.QLabel(self.centralwidget)
self.amp_value.setGeometry(QtCore.QRect(470, 420, 111, 21))
self.amp_value.setObjectName(_fromUtf8("amp_value"))
self.freq_value = QtGui.QLabel(self.centralwidget)
self.freq_value.setGeometry(QtCore.QRect(470, 440, 111, 21))
self.freq_value.setObjectName(_fromUtf8("freq_value"))
self.przes_value = QtGui.QLabel(self.centralwidget)
self.przes_value.setGeometry(QtCore.QRect(470, 460, 111, 21))
self.przes_value.setObjectName(_fromUtf8("przes_value"))
self.chi_value = QtGui.QLabel(self.centralwidget)
self.chi_value.setGeometry(QtCore.QRect(690, 420, 101, 21))
self.chi_value.setObjectName(_fromUtf8("chi_value"))
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.spinbox_amp.setMaximum(10)
self.spinbox_amp.setMinimum(0.1)
self.spinbox_freq.setMaximum(10)
self.spinbox_ilePkt.setMaximum(10000)
self.spinbox_ilePkt.setMinimum(100)
self.spinbox_przesuniecie.setMinimum(1)
self.spinbox_przesuniecie.setMaximum(10)
self.rysuj_button.clicked.connect(self.start)
self.initSpinBox()
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "Fitter", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Wykres", None))
self.iloscPkt_label.setText(_translate("MainWindow", "Ilosc punktow", None))
self.rozrzutPkt_label.setText(_translate("MainWindow", "Rozrzut punktow", None))
self.zakresOd_label.setText(_translate("MainWindow", "Zakres x od", None))
self.zakresDo_label.setText(_translate("MainWindow", "do", None))
self.rozklad_label.setText(_translate("MainWindow", "<b>Rozklad punktow:</b>", None))
self.funkcja_label.setText(_translate("MainWindow", "<b>Funkcja: sinus</b>", None))
self.amplituda_label.setText(_translate("MainWindow", "Amplituda:", None))
self.czestotliwosc_label.setText(_translate("MainWindow", "Czestotliwosc:", None))
self.przesuniecie_label.setText(_translate("MainWindow", "Przesuniecie:", None))
self.checkBox_poczatkowa.setText(_translate("MainWindow", "Funkcja poczatkowa", None))
self.checkBox_dopasowana.setText(_translate("MainWindow", "Funkcja dopasowana", None))
self.checkBox_dane.setText(_translate("MainWindow", "Dane", None))
self.rysuj_label.setText(_translate("MainWindow", "<b>Rysuj na wykresie:</b>", None))
self.rysuj_button.setText(_translate("MainWindow", "Rysuj", None))
self.dopasowane_label.setText(_translate("MainWindow", "<b>Dopasowane dane:</b>", None))
self.amp_dopasowane_label.setText(_translate("MainWindow", "Amplituda:", None))
self.freq_dopasowane_label.setText(_translate("MainWindow", "Czestotliwosc:", None))
self.przez_dopasowane_label.setText(_translate("MainWindow", "Przesuniecie:", None))
self.chi_label.setText(_translate("MainWindow", "Chi square:", None))
self.amp_value.setText(_translate("MainWindow", "x", None))
self.freq_value.setText(_translate("MainWindow", "x", None))
self.przes_value.setText(_translate("MainWindow", "x", None))
self.chi_value.setText(_translate("MainWindow", "x", None))
def testStraightLineParameter( self, plot=False ):
"""
test slope fit
1. Compare PolynomialModel(1) with chain of PowerModel(0) + PowerModel(1)
2. Fix parameters in PolynomialModel
"""
print( "\n Fitter Test 1 \n" )
model = PolynomialModel( 1 )
fitter = Fitter( self.x, model )
model0 = PowerModel( 0 )
model1 = PowerModel( 1 )
model0.addModel( model1 )
altfit = QRFitter( self.x, model0 )
yy = self.aa + self.bb * self.x
y = yy + self.noise
print( "Testing Straight Line fit" )
self.assertTrue( model1.npchain == 2 )
par = fitter.fit( y )
alt = altfit.fit( y )
print( "offst = %f alt = %f truth = %f"%(par[0], alt[0], self.aa) )
print( "slope = %f alt = %f truth = %f"%(par[1], alt[1], self.bb) )
assertAAE( par, alt )
chisq = fitter.chisq
altch = altfit.chisq
print( "chisq = %f alt = %f"%( chisq, altch) )
self.assertTrue( self.eq(chisq, altch) )
std = fitter.standardDeviations
ast = altfit.standardDeviations
print( "stdev = %f alt = %f"%(std[0], ast[0]) )
print( "stdev = %f alt = %f"%(std[1], ast[1]) )
assertAAE( std, ast )
print( " par ", par, " stdv ", std, chisq )
for k in range( 5 ) :
y1 = yy + 0.3 * numpy.random.randn( 11 )
par1 = fitter.fit( y1 )
std1 = fitter.stdevs
chi1 = fitter.chisq
print( k, " par ", par1, " stdv ", std1, chi1 )
altfit.needsNewDecomposition = True
par1 = altfit.fit( y, keep={0:par[0]} )
print( par1, par )
std1 = altfit.stdevs
print( std, std1 )
if plot :
FitPlot.plotFit( self.x, y, model0 )
self.assertTrue( 2 == len( par1) )
assertAAE( par, par1 )
self.assertTrue( model0.npchain == 2 )
mp = model0.parameters
print( mp, par, par1 )
assertAAE( mp, par1 )
altfit = QRFitter( self.x, model0, keep={0:par[0]+0.001} )
par1 = altfit.fit( y )
std1 = altfit.stdevs
print( par, par1 )
print( std, std1 )
if plot :
FitPlot.plotFit( self.x, y, model0 )
self.assertTrue( 2 == len( par1) )
assertAAE( par, par1, 3 )
self.assertTrue( std1[0] == 0 )
error1 = altfit.monteCarloError( )
print( "error = ", error1 )
am = float(raw_input("Wprowadz amplitude\n"))
przes = float(raw_input("Wprowadz przesuniecie\n"))
d.setData(przes,okr,pom_okr,am,zak)
break
except ValueError:
print 'Wprowadzono niepoprawne dane - sprobuj jeszcze raz \n'
elif(std== str(1)):
break
if (d.getNoise()>=2.5):
print 'Uwaga! Wybrano wartosc zaklocen: '+ str(d.getNoise()) +'. Moze to spowodowac bledy rozwiazania'
#storage = d.getData()
data = d.generateData(math.sin)
f = Fitter()
fit_data = f.fit(sin, data,[1])
fit = [data[0], fit_data]
chi = StatAnalyser.chi2(data[1], fit_data)
chi_norm = StatAnalyser.chi2Norm(chi, data[1])
print 'Test Pearsona (chi^2) = '+ str(chi) + ' wartosc chi2 znormalizowana: '+str(chi_norm)
plot = Plotter()
plot.make_plot(data)
plot.make_plot([data[0],sin(data[0],d.getAmp())], 'fun')
plot.make_plot(fit,'fit')
plot.draw_plot()
print '**********************************************************************'
from fitting_models import Sinusoidal
import numpy as np
import matplotlib.pyplot as plt
from Fitter import Fitter
from lmfit import Model, Parameter, Parameters
# -------- create data set -------------------
coordinates = np.arange(60)
A = 2
phi = 0.5
omega = 0.5
offset = 10
data = A * np.sin(omega * coordinates + phi) + offset + A * np.random.rand(
len(coordinates))
#-------- test model package---------------
params = Sinusoidal.guess_allParams(coordinates, data)
#-------- test model Fitter---------------
test = Fitter(Sinusoidal)
params = Parameters()
result = test.fit(coordinates, data, params)
plt.figure()
plt.plot(coordinates, data)
plt.plot(coordinates, result.best_fit)
def test3( self, plot=False ) :
print( "====test3============================" )
nn = 10
x = numpy.linspace( 0, 2, nn, dtype=float )
ym = 0.3 + 0.5 * x
nf = 0.1
numpy.random.seed( 2345 )
noise = numpy.random.randn( nn )
y = ym + nf * noise
limits = [-1,2]
pm = PolynomialModel( 1 )
bf = Fitter( x, pm, fixedScale=0.5 )
pars = bf.fit( y )
logz0 = bf.getLogZ( limits=limits )
logl0 = bf.logLikelihood
print( "pars ", fmt( pars ) )
print( "stdv ", fmt( bf.stdevs ) )
print( "logZ ", fmt( logz0 ), " logL ", fmt( logl0 ) )
if plot :
plt.figure( "model" )
plotFit( x, data=y, model=pm, ftr=bf, truth=ym, show=False )
errdis = GaussErrorDistribution ( x, y, scale=0.5 )
logz1, logl1 = plotErrdis2d( errdis, pm, limits=limits, max=0,
plot=plot )
if plot :
plt.plot( pars[0], pars[1], 'k.' )
print( "logZ ", fmt( logz1 ), " logL ", fmt( logl1 ) )
model = PolynomialModel( 1 )
model.setLimits( lowLimits=limits[0], highLimits=limits[1] )
dis = GaussErrorDistribution( x, y, scale=0.5 )
ns = NestedSampler( x, model, y, distribution=dis, verbose=0 )
yfit = ns.sample()
par2 = ns.parameters
logz2 = ns.logZ
dlz2 = ns.logZprecision
print( "pars ", fmt( par2 ) )
print( "stdv ", fmt( ns.stdevs ) )
print( "logZ ", fmt( logz2 ), " +- ", fmt( dlz2 ) )
# print( logz0 - logz1, logz0 - logz2 )
self.assertTrue( abs( logz2 - logz0 ) < dlz2 )
samples = ns.samples
parevo =samples.getParameterEvolution()
llevo = samples.getLogLikelihoodEvolution()
lwevo = samples.getLogWeightEvolution()
assertAAE( numpy.sum( numpy.exp( lwevo ) ), 1.0 )
if plot :
plt.plot( parevo[:,0], parevo[:,1], 'k,' )
plt.figure( "model" ) # grab again
err = samples.monteCarloError( x )
plt.plot( x, yfit + err, 'b-' )
plt.plot( x, yfit - err, 'b-' )
plt.show()
def test4( self, plot=False ) :
print( "====test4============================" )
nn = 100
x = numpy.arange( nn, dtype=float ) / 50
ym = 0.4 + 0.0 * x
nf = 0.5
numpy.random.seed( 2345 )
noise = numpy.random.randn( nn )
y = ym + nf * noise
limits = [0,1]
nslim = [0.1,1.0]
pm = PolynomialModel( 0 )
bf = Fitter( x, pm )
pars = bf.fit( y )
scale = bf.scale
logz0 = bf.getLogZ( limits=limits, noiseLimits=nslim )
logl0 = bf.logLikelihood
print( "pars ", fmt( pars ), " scale ", fmt( scale ) )
print( "stdv ", fmt( bf.stdevs ) )
print( "logZ ", fmt( logz0 ), " logL ", fmt( logl0 ) )
if plot :
plt.figure( "model" )
plotFit( x, data=y, model=pm, ftr=bf, truth=ym, show=False )
errdis = GaussErrorDistribution ( x, y )
logz1, logl1 = plotErrdis2d( errdis, pm, limits=limits, nslim=nslim,
plot=plot )
if plot :
plt.plot( pars[0], scale, 'k.' )
print( "logZ ", fmt( logz1 ), " logL ", fmt( logl1 ) )
model = PolynomialModel( 0 )
model.setLimits( lowLimits=limits[0], highLimits=limits[1] )
dis = GaussErrorDistribution( x, y )
dis.setLimits( nslim )
ns = NestedSampler( x, model, y, distribution=dis, verbose=0 )
yfit = ns.sample()
par2 = ns.parameters
scl2 = ns.scale
logz2 = ns.logZ
dlz2 = ns.logZprecision
print( "pars ", fmt( par2 ), " scale ", fmt( scl2 ) )
print( "stdv ", fmt( ns.stdevs ) )
print( "logZ ", fmt( logz2 ), " +- ", fmt( dlz2 ) )
self.assertTrue( abs( logz2 - logz1 ) < 2 * dlz2 )
samples = ns.samples
parevo =samples.getParameterEvolution()
scevo =samples.getScaleEvolution()
llevo = samples.getLogLikelihoodEvolution()
lwevo = samples.getLogWeightEvolution()
assertAAE( numpy.sum( numpy.exp( lwevo ) ), 1.0 )
if plot :
plt.plot( parevo[:,0], scevo, 'k,' )
plt.figure( "model" ) # grab again
err = samples.monteCarloError( x )
plt.plot( x, yfit + err, 'b-' )
plt.plot( x, yfit - err, 'b-' )
plt.show()
return a * x**b + c
if int(raw_input("sin -1, weird function -2\n")) == 1:
gen_func = math.sin
p0 = []
p1 = [1, 1, 1, 1]
fit_func = my_sin
else:
gen_func = func
print "dziwne rownanie a*x^b + c"
p0 = [
float(raw_input("podaj wps. a\n")),
float(raw_input("podaj wps. b\n")),
float(raw_input("podaj wps. c\n"))
]
fit_func = func
p1 = [1, 1, 1]
data_points = generator.generate_data_points(gen_func, p0)
fit_data_y = Fitter.fit(fit_func, data_points, p1)
fit_data = [data_points[0], fit_data_y]
chi, nchi = StatAnalyser.chi2(data_points[1], fit_data_y, len(p1))
print "wartosc testu chi^2: ", chi, "znormalizowana wartosc chi: ", nchi, "\n"
plot = Plotter()
plot.plot_data_points(data_points)
plot.plot_fit_curve(fit_data)
plot.show_plot()