Spis treści 1 Wstęp 2 Regresja 2.1 Regresja liniowa 2.1.1 Przykład: Dopasowanie prostej do punktów (zakładamy jednakową wariancję Y dla każdego X) 2.1.2 Ocena jakości dopasownia 2.1.2.1 Współczynnik 2.1.2.2 Test F dla hipotezy o braku korelacji 2.1.2.3 Przedziały ufności dla parametrów 2.1.2.4 Przedziały ufności dla modelu 2.1.2.5 Przedziały ufności dla obserwacji 2.1.2.6 Test 2.2 Dopasowanie krzywej do danych gdy wariancje dla poszczególnych punktów pomiarowych są różne 2.2.1 Dopasowanie dowolnej funkcji 2.2.2 Dopasowanie wielomianu Wstęp Załóżmy, że mamy dwie zmienne losowe ciągłe i. Chcielibyśmy wykorzystać wiedzę o wartościach zmiennej do przewidywania wartości zmiennej. Mówimy, że zmienna jest niezależna, a zmienna zależna. W fizyce taką wiedzę opisujemy przy pomocy równań. Równania fizyczne często wyrażają związki przyczynowo-skutkowe. W takim wypadku, która zmienna jest zależna, a która niezależna ma głębszy sens. Jednak nie zawsze tak musi być. Wartości dwóch zmiennych mogą zależeć od trzeciej nieobserwowanej zmiennej. W tej sytuacji wiedza o wartości jednej z tych zmiennych może być wykorzystana do przewidywania wartości drugiej, ale nie ma między nimi związku przyczynowo-skutkowego. Regresja W ogólności, dla każdej wartości zmiennej mamy rozkład wartości zmiennej. # -*- coding: utf-8 -*- import scipy.stats as st import pylab as py import numpy as np Przykład: rozkłady Y dla każdego punktu X # symuowana zależność ma następującą postać y = b0 + b1*x # wartości parametrów b0 = 1 b1 = 3
X = np.arange(, 10,0.5) # będę symulował zbieranie n wartości Y dlakażdego X[i], zakładam to samo odchylenie standardowe odch_std = 1 n = 30 Y = np.zeros((n,len(x))) for i in range(len(x)): Y[:,i] = b0 + b1*x[i] + st.norm.rvs(size = n, loc=, scale = odch_std) # narysujmy ten zbiór punktów for j in range(len(x)): py.plot(x, Y[j,:],'b,') # wyróżnimy średnie py.plot(x,np.mean(y,),'ro') # i odchykenia standardowe: py.errorbar(x,np.mean(y,),odch_std,ecolor = 'k',elinewidth = 8) py.show() Regresja liniowa Dalej będziemy rozważać regresję liniową, tzn. założymy, że punkty model liniowy o następującym równaniu: są generowane przez współczynniki i można wyestymować stosując metodę największej wiarygodności: Z tymi współczynnikami otrzymujemy równanie opisujące prostą regresji: Zakłądając, że pochodzi z rozkładu normalnego o wariancji estymowane współczynniki są zmiennymi losowymi pochodzącymi z rozkładów normalnego o średniej takiej jak wyestymowany współczynnik i wariancji odpowiednio:
Wariancję można estymować przez: Warto tu zwrócić uwagę na prosty fakt, że niepewność oszacowania współczynników można zmniejszyć zwiększając zakres zmiennej. Funkcję estymującą parametry i ich standardowe odchylenia można zaimplementować w pythonie następująco: # -*- coding: utf-8 -*- import scipy.stats as st import pylab as py import numpy as np def regresja_liniowa(x,y): '''równanie dopasowywanej prostej to y = b0 + b1*x argumenty: X - zmienna niezależna Y - zmienna zależna funkcja zwraca: b0, b1, - estymaty parametrów s_b0, s_b1, - estymaty standardowego odchylenia parametrów residua - różnice między punktami pomiarowymi a punktami na dopasowanej prostej ''' N = len(x) x_sr = np.mean(x) y_sr = np.mean(y) # estymatory parametrów # korzystamy z tego że numpy wykonuje odejmowania i potęgowania dla każdego elementu tablicy X i Y b1 = np.sum((x-x_sr)*(y-y_sr))/np.sum((x-x_sr)**2) b0 = y_sr - b1*x_sr modelu # teraz liczymy kilka rzeczy przydatnych do oceny jakości modelu Y_reg = b0 + b1*x # wartości Y przewidywane przez model residua = Y - Y_reg # residua, czyli zmienność Y nie wynikająca z
sse = np.sum(residua**2) # estymator wariancji residuów, bywa nazywany średnim błędem kwadratowym regresji : v_e = sse/(n-2) # estymatory standardowych błędów parametrów s_b0 = np.sqrt(v_e) * np.sqrt(1.0/n + x_sr**2/np.sum( (X-x_sr)**2)) s_b1 = np.sqrt(v_e) * np.sqrt( 1.0/np.sum( (X -x_sr)**2 )) return (b0, b1, s_b0, s_b1, residua ) Przykład: Dopasowanie prostej do punktów (zakładamy jednakową wariancję Y dla każdego X) Wytwórzmy dane zgodnie z modelem: i : # symulowana zależność ma następującą postać y = b0 + b1*x # wartości parametrów b0 = -13.0 b1 = 3.0 X = np.arange(30, 70, 0.5) sigma = 19.0 n = 1 Y = np.zeros(len(x)) for i in range(len(x)): Y[i] = b0 + b1*x[i] + st.norm.rvs(size = n, loc=, scale = sigma) Korzystając ze zdefiniowanej powyżej funkcji regresja_liniowa estymujemy parametry i ich odchylenia standardowe: (b0, b1, s_b0, s_b1, residua ) = regresja_liniowa(x,y) print('równanie prostej: y = b0 + b1*x') print('dopasowane współczynniki: b0 = %.3f, b1 = %.3f' %(b0, b1)) print('s_b0 = %.4f, s_b1= %.4f '%(s_b0, s_b1)) py.errorbar(x,y,sigma, fmt = None) Y_reg = b0 + b1*x py.plot(x,y_reg)
py.show() Ocena jakości dopasownia Współczynnik Aby wyrazić współczynnik miarą zmienności. potrzebujemy następujących wyrażeń - sum kwadratów (ss). Są one - całkowita suma kwadratów - proporcjonalna do wariancji próby, - suma kwadratów regresji - zwana też wyjaśnioną sumą kwadratów, - suma kwadratów residuów - niewyjaśniona suma kwadratów. Poszczególne składniki wymienionych powyżej sum kwadratów są zilustrowane na poniższym rysunku. Plik:Regresja1.svg Dla wybranego punktu zaznaczono różnice będące składnikami poszczególnych sum kwadratów Implementacja: y_sr = np.mean(y) ss_tot = np.sum( (Y - y_sr)**2 ) ss_reg = np.sum( (Y_reg - y_sr)**2 ) ss_err = np.sum( (residua)**2 ) mając te sumy definiujemy jako: R2 = 1 - ss_err/ss_tot print('r2 = %.2f' %(R2)) W przypadku regresji liniowej numerycznie:. Możemy to sprawdzić analitycznie i print('ss_tot = %.3f' %(ss_tot)) print('ss_reg + ss_err =%.3f'%(ss_reg+ss_err))
czyli, można więc interpretować jako frakcję zmienności Y tłumaczoną przez model. W przypadku regresji liniowej współczynnik równy jest kwadratowi współczynnika korelacji (dowód) Test F dla hipotezy o braku korelacji Często interesujące jest zweryfikowanie hipotezy o istotności zależności między Y a X (proszę nie mylić tego z istnieniem związku przyczynowo-skutkowego). Matematycznie równoważne jest to postawieniu hipotezy: albo: Wykorzystamy do tego test równości wariancji oparty o rozkład F. Jeśli zgodnie z to prosta regresji jest pozioma i wariancja wyjaśniona przez regresję (proporcjonalna do ) jest równa wariancji niewyjaśnionej (proporcjonalna do ). Wariancje te można estymować dzieląc odpowiednie sumy kwadratów zdefiniowane w poprzednim paragrafie przez odpowiadającą im liczbę stopni swobody. Jeśli mamy N punktów danych, to: Zatem: liczba stopni swobody dla jest, poniważ jeden stopień swobody jest tracony na obliczenie średniej, liczba stopni swobody dla jest, ponieważ do policzenia tej sumy kwadratów musimy wyznaczyć dwa parametry prostej, liczba stopni swobody odpowiadająca jest 1, bo jest związana jest z poprzednimi sumami kwadratów równaniem, czyli swobody jest tyle ile wynosi różnica w stopniach swobody tamtych sum. estymator wariancji wyjaśnionej:
estymator wariancji niewyjaśnionej: Wielkość podlega rozkładowi F o stopniach swobody. W naszym przykładzie: # test F N = len(x) F = (ss_reg *(N-2))/ss_err p_f = 1-st.f.cdf(F,1,N-2) print('f = %.2f, p_f = %.2f'%(F, p_f)) Wnioskowanie: Jeśli p_f jest duże to nie mamy powodu aby odrzucić hipotezę zerową. Jeśli zaś jest ono mniejsze niż ustalony poziom istotności to odrzucamy hipotezę zerową i przyjmujemy alternatywną. Przedziały ufności dla parametrów Przedziały ufności dla parametrów i pokazują zakres, w jakim z zadanym prawdopodobieństwem znajdują się ich "prawdziwe" wartości. Jeśli residua mają rozkład normalny, to estymatory parametrów i również będą miały rozkład normalny. Zmienne: podlegają rozkładowi t z (N 2) stopniami swobody. Używając powyższych statystyk t można skonstruować przedziały ufności w standardowy sposób (porównaj z przykładem). Jeśli przedział ma mieć poziom ufności to potrzebna nam będzie wartość krytyczna z rozkładu większej od niej jest. Wówczas: taka, że prawdopodobieństwo zaobserwowania wartości t nie
oraz Implementacja: # przedziały ufności: alpha = 0.05 # zakładam 95% przedział ufności # wartość krytyczna w rozkładzie t t_kryt = st.t.ppf(alpha/2, N-2) b0_l = b0 + s_b0*t_kryt b0_h = b0 - s_b0*t_kryt b1_l = b1 + s_b1*t_kryt b1_h = b1 - s_b1*t_kryt print('%.1f procentowe przedziały ufności parametrów:'%((1-alpha)*100)) print('b0: [%.2f %.2f ] '%(b0_l, b0_h)) print('b1: [%.2f %.2f ] '%(b1_l, b1_h)) Przedziały ufności dla modelu Widzieliśmy, że parametry dopasowanej prostej nie są wyznaczone dokładnie. Tzn. jeśli dostalibyśmy inne realizacje danych (X,Y) to ta sama procedura regresji zwraca nieco inne parametry modelu. Jak widzieliśmy powyżej można wyznaczyć przedziały ufności wewnątrz których parametry te znajdują się z określonym prawdopodobieństwem. Różnym parametrom odpowiadają różne proste. Proste te wyznaczają na płaszczyźnie (x,y) pewien obszar. Obszar ten to przedział ufności dla modelu. Jego granice można wyznaczyć obliczając dla każdej wartości x błąd standardowy regresji ze wzoru: odległość krzywej wyznaczającej obszar ufności od prostej regresji znajdujemy mnożąc ten błąd standardowy przez odpowiednią wartość krytyczną z rozkładu : Implementacja: # Przedział ufności modelu: alpha = 0.05 # zakładam 95% przedział ufności # wartość krytyczna w rozkładzie t t_kryt = st.t.ppf(alpha/2, N-2) sse = np.sum(residua**2)
# estymator wariancji residuów, bywa nazywany średnim błędem kwadratowym regresji : v_e = sse/(n-2) x_sr = np.mean(x) # Odległość brzegów przedziału ufności od prostej regresji d = t_kryt*np.sqrt(v_e)*np.sqrt(1.0/n + (X- x_sr)**2/np.sum((x-x_sr)**2)) # Ilustracja: dla każdego X cieniujemy obszar pomiędzy Y_reg-d,Y_reg+d i nadajemy mu przezroczystość 0.5 py.fill_between(x,y_reg-d,y_reg+d,alpha=0.5) Przedziały ufności dla obserwacji Przedział zmienności dla modelu nie mówi nam wiele o tym jak daleko od wyznaczonej prostej mogą pojawiać się nowe obserwacje (x,y). Aby zobrazować obszar, w którym z określonym prawdopodobieństwem mogą wystąpić nowe obserwacje potrzebujemy przedziału ufności dla obserwacji. Jego granice można wyznaczyć obliczając dla każdej wartości x błąd standardowy ze wzoru: odległość krzywej wyznaczającej obszar ufności od prostej regresji znajdujemy mnożąc ten błąd standardowy przez odpowiednią wartość krytyczną z rozkładu : # przedział ufności na obserwacje d = t_kryt*np.sqrt(v_e)*np.sqrt(1+1.0/n + (X- x_sr)**2/np.sum((x-x_sr)**2)) py.fill_between(x,y_reg-d,y_reg+d, facecolor='gray',alpha=0.5) Test Jeśli znamy wariancję błędu pomiarowego można zastosować test do oceny jakości dopasowania. Po pierwsze powinniśmy przetestować czy residua mają rozkład normalny W, p =st.shapiro(residua) print('test normalności residuów: p = %.3f'%(p)) Jeśli tak to zmienna:
podlega rozkładowi o ilości stopni swobody (n - ilość estymowanych parametrów), czyli u nas N-2. Możemy zbadać jakie jest prawdopodobieństwo zaobserwowania takiej ( ), bądź bardziej ekstremalnej wartości : chi2 = np.sum(residua**2)/sigma**2 N = len(x) if chi2 < N-2: p_chi2 = st.chi2.cdf(chi2, N-2) else: p_chi2 = 1 - st.chi2.cdf(chi2, N-2) print('chi2 = %.2f, p_chi2 = %.3f' %(chi2, p_chi2)) Czasem używamy zredukowanego, czyli podzielonego przez liczbę stopni swobody : Jeśli jest on znacząco większy niż 1 to model nie pasuje do danych, lub nie doszacowaliśmy standardowego odchylenia. Jeśli jest sporo mniejszy niż 1 to prawdopodobnie oszacowane przez nas jest większe niż rzeczywiste. To jakościowe porównanie można uściślić szacując prawdopodobieństwo zaobserwowania wartości bardziej ekstremalnych niż otrzymane w dopasowaniu. Zmienna podlega innemu rozkładowi prawdopodobieństwa niż, możemy go jednak łatwo wyznaczyć w drodze symulacji: chi2_zred = chi2/(n-2) # potrzebny jest nam rozkład chi2_zred: N_dist = 100000 dist_chi2_zred = np.sum(st.norm.rvs(size=(n-2,n_dist))**2,)/(n-2) if chi2_zred>1: p_chi2_zred = np.sum(dist_chi2_zred>=chi2_zred)/float(n_dist) else: p_chi2_zred = np.sum(dist_chi2_zred<=chi2_zred)/float(n_dist) print('chi2_zred = %.2f, p_chi2_zred = %.3f' %(chi2_zred, p_chi2_zred)) Dopasowanie krzywej do danych gdy wariancje dla poszczególnych punktów pomiarowych są różne Często w fizyce potrzebujemy dopasować jakąś bardziej skomplikowaną zależność niż prosta. Często też potrafimy oszacować błędy pomiarowe dla różnych wartości zmiennej niezależnej, przy czym może się zdarzyć, że błędy te nie są jednakowe dla różnych wartości zmiennej niezależnej. Do
dopasowania współczynników używamy zasady największej wiarygodności, która prowadzi do procedur minimalizacji ważonego średniego błędu kwadratowego. Możemy wówczas użyć standardowych procedur minimalizacji gradientowej. Należy jednak pamiętać, że metody gradientowe znajdują najbliższe minimum lokalne analizowanej funkcji. W przypadku funkcji nieliniowych skutkiem tego jest zależność wyniku od punktu startu minimalizacji. Dopasowanie dowolnej funkcji Poniżej rozważymy przykład dopasowania zależności wykładniczej. # -*- coding: utf-8 -*- import scipy.stats as st import scipy.optimize as opt import pylab as py import numpy as np # funkcja używana do symulowania danych def zanik(x, amp, wykladnik, blad_wzgledny): '''Definicja funkcji zaniku wykładniczego. Użyjemy jej do wytworzenia danych''' y = amp * (x**wykladnik) # idealne dane sigma = blad_wzgledny * y # zakładamy, że stały jest błąd względny pomiaru # przeliczamy go na standardowe odchylenie symulowanego błędu # symulujemy szum z obliczonym odchyleniem standardowym i dodajemy go do danych idealnych y += st.norm.rvs(size=num_points) * sigma return (y, sigma) # Funkcja, którą chcemy dopasować do danych: def funkcja_do_fitowania(x,a,b): y = a*x**b return y def funkcja_bledu(x, y, funkcja, params, err): '''Suma kwadratów tej funkcji jest minimalizowana w procesie optymalizacji parametrów. Nam przyda się do obliczenia residuów.''' y_fit = funkcja(x, *params) # aktualne wartości y z dopasowania residuum = y-y_fit # residua wchodzą do sumy kwadratów z wagą odwrotnie proporcjonalną do standardowego odchylenia residuum_wazone = residuum/ err return residuum_wazone # Generujemy punkty z szumem
num_points = 20 X = np.linspace(1.1, 10.1, num_points) Y, sigma = zanik(x, 10.0, -2.0, 0.1) # symulowane dane # Dopasowujemy parametry # nie musimy podawać wartości startowych (params_init) dla procedury minimalizacji (wtedy funkcja zakłada wartości startowe równe 1) # jednak zazwyczaj dobrze jest podpowiedzieć algorytmowi, gdzie powinien zacząć # nie musimy również podawać wartości sigma, ale jeśli są one różne dla różnych punktów, to podanie ich sprawi, że algorytm będzie się bardziej troszczył # o dopasowanie do punktów pomiarowych zmierzonych z dobrą dokładnością, a bardziej swobodnie podejdzie do tych o dużych niepewnościach params_init = [2.0, -1.0] params_final, covar = opt.curve_fit(funkcja_do_fitowania,x,y,params_init,sigma) print("dopasowane parametry",params_final) print("macierz kowariancji\n",covar) # dopasowane parametry amp=params_final[] wykladnik=params_final[1] # standardowe błędy dopasowania amp_err = np.sqrt(covar[][]) wykladnik_err = np.sqrt(covar[1][1]) # test chi2 dobroci dopasowania. # Jeśli znamy wariancję błędu pomiarowego można zastosować test chi2 do oceny jakości dopasowania. # Po pierwsze powinniśmy przetestować czy residua mają rozkład normalny residua = funkcja_bledu(x, Y, funkcja_do_fitowania, params_final, sigma)# tym razem residua już są podzielone przez standardowe odchylenie, każde przez swoje W, p =st.shapiro(residua) print('test normalności residuów: p = %.3f'%(p)) # jeśli tak to zmienna: chi2 = np.sum(residua**2) # podlega rozkładowi chi-kwadrat o N - n ilości stopni swobody (n - ilość fitowanych parametrów), czyli u nas N-2 # możemy zbadać jakie jest prawdopodobieństwo zaobserwowania takiej, bądź bardziej ekstremalnej wartości chi2:
N = len (X) liczba_stopni_swobody = N-len(params_final) # liczba punktów - liczba parametrów if chi2 < liczba_stopni_swobody: p_chi2 = st.chi2.cdf(chi2, liczba_stopni_swobody) else: p_chi2 = st.chi2.sf(chi2, liczba_stopni_swobody) # równoważne 1- st.chi2.cdf(chi2, N-2), ale sf ma lepszą dokładność dla małych wartości print('chi2 = %.2f, p_chi2 = %.3f' %(chi2, p_chi2)) # czasem używamy zredukowanego chi2, czyli podzielonego przez ilość stopni swobody chi2_zred = chi2/liczba_stopni_swobody # jeśli jest on znacząco większy niż 1 to model nie pasuje do danych, lub nie doszacowaliśmy sigmy, # jeśli jest sporo mniejszy niż 1 to prawdopodobnie oszacowane przez nas sigma jest większe niż rzeczywiste # potrzebny jest nam rozkład chi2_zred: N_dist = 100000 dist_chi2_zred = np.sum(st.norm.rvs(size=(liczba_stopni_swobody,n_dist))**2,)/liczba_stopni_swobody p_chi2_zred = np.sum(dist_chi2_zred>=chi2_zred)/float(n_dist) print('chi2_zred = %.2f, p_chi2_zred = %.3f' %(chi2_zred, p_chi2_zred)) ########## # wykres ########## py.subplot(2,1,1) py.plot(x, funkcja_do_fitowania(x,amp,wykladnik)) # Fit py.errorbar(x, Y, yerr=sigma, fmt='k.') # Dane i błędy py.text(5, 6.5, 'amplituda = %5.2f +/- %5.2f' % (amp, amp_err)) py.text(5, 5.5, u'wykładnik = %5.2f +/- %5.2f' % (wykladnik, wykladnik_err)) py.title(u'dopasowanie metodą najmniejszych kwadratów') py.xlabel('x') py.ylabel('y') py.xlim(1, 11) py.subplot(2,1,2) py.plot(x, residua) # residua py.xlabel('x') py.ylabel('dy') py.title(u'wykres residuów') py.show() Dopasowanie wielomianu Poniżej rozważymy przykład dopasowania zależności wielomianowej.
# -*- coding: utf-8 -*- import scipy.stats as st import pylab as py import numpy as np # funkcja używana do symulowania danych def wielomian_z_szumem(x, wspolczynniki,blad_wzgledny): '''Definicja funkcji wielomianowej. Użyjemy jej do wytworzenia danych''' W = np.poly1d(wspolczynniki) # funkcja zwracająca obiekt wielomianu o zadanych wspolczynnikach #można go używać tak, jak zwykłej funkcji, ale obsługuje też działania na wielomianach y = W(X)# idealne dane sigma = blad_wzgledny * y # zakładamy, że stały jest błąd względny pomiaru # przeliczamy go na standardowe odchylenie symulowanego błędu # symulujemy szum z obliczonym odchyleniem standardowym i dodajemy go do danych idealnych y += st.norm.rvs(size=num_points) * sigma return (y, sigma) def funkcja_bledu_dla_wielomianow(x, y, wspolczynniki, err): '''Suma kwadratów tej funkcji jest minimalizowana w procesie optymalizacji parametrów. Nam przyda się do obliczenia residuów.''' W = np.poly1d(wspolczynniki) y_fit = W(x) # aktualne wartości y z dopasowania residuum = y-y_fit # residua wchodzą do sumy kwadratów z wagą odwrotnie proporcjonalną do standardowego odchylenia residuum_wazone = residuum/ err return residuum_wazone # Generujemy punkty z szumem num_points = 20 X = np.linspace(-4, 6, num_points) wspolczynniki_wielomianu= (0.3,1,-2,4) stopien_wielomianu=len(wspolczynniki_wielomianu)-1 blad_wzgledny_pomiaru=0.1 Y, sigma = wielomian_z_szumem(x, wspolczynniki_wielomianu, blad_wzgledny_pomiaru) # symulowane dane # Dopasowujemy parametry # tym razem skorzystamy z funkcji np.polyfit, która nie potrzebuje parametrów początkowych, ani zdefiniowanej funkcji, którą ma dopasować
# podajemy jej tylko nasze dane oraz stopień wielomianu, który ma dopasować oraz opcjonalne wagi # UWAGA! Tym razem wagi muszą być odwrotnością odchyleń standardowych (1/sigma, a nie sigma, jak w curve_fit) # funkcja ta domyślnie zwraca tylko dopasowane parametry (wspolczynniki wielomianu), a nie zwraca macierzy kowariancji, # jeśli jest nam ona potrzebna, to musimy jej zarządać poprzez dodanie opcji cov=true (full=false, ale to jest domyślnie) params_final, covar=np.polyfit(x, Y, deg=stopien_wielomianu, w=1/sigma, cov=true) print("dopasowane wspolczynniki wielomianu",params_final) print("macierz kowariancji\n",covar) # standardowe błędy dopasowania niepewnosci=[] for i in range(len(params_final)): niepewnosci.append(np.sqrt(covar[i][i])) print(niepewnosci) # test chi2 dobroci dopasowania. # Jeśli znamy wariancję błędu pomiarowego można zastosować test chi2 do oceny jakości dopasowania. # Po pierwsze powinniśmy przetestować czy residua mają rozkład normalny residua = funkcja_bledu_dla_wielomianow(x, Y, params_final, sigma)# tym razem residua już są podzielone przez standardowe odchylenie, każde przez swoje W, p =st.shapiro(residua) print('test normalności residuów: p = %.3f'%(p)) # jeśli tak to zmienna: chi2 = np.sum(residua**2) # podlega rozkładowi chi-kwadrat o N - n ilości stopni swobody (n - ilość fitowanych parametrów), czyli u nas N-2 # możemy zbadać jakie jest prawdopodobieństwo zaobserwowania takiej, bądź bardziej ekstremalnej wartości chi2: N = len (X) liczba_stopni_swobody = N-len(params_final) # liczba punktów - liczba parametrów if chi2 < liczba_stopni_swobody: p_chi2 = st.chi2.cdf(chi2, liczba_stopni_swobody) else: p_chi2 = st.chi2.sf(chi2, liczba_stopni_swobody) # równoważne 1- st.chi2.cdf(chi2, N-2), ale sf ma lepszą dokładność dla małych wartości
print('chi2 = %.2f, p_chi2 = %.3f' %(chi2, p_chi2)) # czasem używamy zredukowanego chi2, czyli podzielonego przez ilość stopni swobody chi2_zred = chi2/liczba_stopni_swobody # jeśli jest on znacząco większy niż 1 to model nie pasuje do danych, lub nie doszacowaliśmy sigmy, # jeśli jest sporo mniejszy niż 1 to prawdopodobnie oszacowane przez nas sigma jest większe niż rzeczywiste # potrzebny jest nam rozkład chi2_zred: N_dist = 100000 dist_chi2_zred = np.sum(st.norm.rvs(size=(liczba_stopni_swobody,n_dist))**2,)/liczba_stopni_swobody p_chi2_zred = np.sum(dist_chi2_zred>=chi2_zred)/float(n_dist) print('chi2_zred = %.2f, p_chi2_zred = %.3f' %(chi2_zred, p_chi2_zred)) ########## # wykres ########## py.subplot(2,1,1) W=np.poly1d(params_final) py.plot(x, W(X)) # Fit py.errorbar(x, Y, yerr=sigma, fmt='k.') # Dane i błędy py.title(u'dopasowanie metodą najmniejszych kwadratów') py.text(-4.6, 92, u'dopasowane współczynniki = '+str(np.round(params_final,3))) py.text(-4.6, 86, u'niepewności współczynników = '+str(np.round(niepewnosci,3))) py.text(-4.6, 80, u'prawdziwe współczynniki = '+str(np.round(wspolczynniki_wielomianu,3))) py.xlabel('x') py.ylabel('y') py.xlim(x.min()-1, X.max()+1) py.subplot(2,1,2) py.plot(x, residua) # residua py.xlabel('x') py.ylabel('dy') py.title(u'wykres residuów') py.show() py.show()