auditstat 0.1.9__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,197 @@
1
+ import matplotlib
2
+ import matplotlib.pyplot as plt
3
+ import numpy as np
4
+ from scipy import stats
5
+ from scipy.special import gammaln
6
+
7
+ from auditstat._formatting import nl_getal, nl_tick_formatter
8
+ from auditstat.sso.max_fout_benaderd_SSO import max_fout_benaderd_SSO
9
+ from auditstat.sso.max_fout_exact_continu_SSO import (
10
+ _betabinom_continu_pdf,
11
+ max_fout_exact_continu_SSO,
12
+ )
13
+ from auditstat.sso.max_fout_exact_SSO import max_fout_exact_SSO
14
+
15
+
16
+ def plot_kanskromme_SSO(n, k, N_klant, zekerheid=0.95, verdeling="binomiaal"):
17
+ """
18
+ Plot de kanskromme (kansdichtheid) van de foutfractie bij de klant,
19
+ voor de exacte, de continu-doorgetrokken-exacte en de benaderde
20
+ methode.
21
+
22
+ De exacte methode gaat uit van de werkelijke, discrete voorspellende
23
+ verdeling (Beta-Binomiaal resp. Negatief-Binomiaal): de foutfractie kan
24
+ alleen de waarden 0/N_klant, 1/N_klant, ..., N_klant/N_klant aannemen.
25
+ Deze wordt getoond als een getrapte, gevulde kromme.
26
+
27
+ De exact-continue methode trekt dezelfde kansmassafunctie analytisch
28
+ door naar reële foutfracties (zie max_fout_exact_continu_SSO), zonder
29
+ de twee onzekerheidslagen (Beta-posterior en steekproefvariabiliteit
30
+ bij de klant) samen te voegen. Deze wordt getoond als een vloeiende
31
+ stippellijn boven op de getrapte kromme.
32
+
33
+ De benaderde methode vervangt dit door een andere, eenvoudiger
34
+ continue verdeling (Beta resp. Gamma) op basis van een effectieve
35
+ steekproefomvang bij de klant (n_klant, k_klant), waarbij de twee
36
+ onzekerheidslagen wél worden samengevoegd tot één enkele. Deze wordt
37
+ getoond als een vloeiende lijn.
38
+
39
+ De bijbehorende maximale foutfracties (bij de gekozen zekerheid) worden
40
+ als verticale stippellijnen getoond.
41
+
42
+ Parameters
43
+ ----------
44
+ n, k : int
45
+ Omvang en aantal fouten in de steekproef bij SSO.
46
+ N_klant : int
47
+ Aantal posten bij de klant.
48
+ zekerheid : float, standaard 0.95
49
+ Gewenste statistische zekerheid.
50
+ verdeling : {"binomiaal", "poisson"}, standaard "binomiaal"
51
+
52
+ Returns
53
+ -------
54
+ matplotlib.figure.Figure
55
+ """
56
+ if verdeling not in ("binomiaal", "poisson"):
57
+ raise ValueError("Kies 'binomiaal' of 'poisson'")
58
+
59
+ exact_max = max_fout_exact_SSO(n, k, N_klant, zekerheid, verdeling)
60
+ exact_continu_max = max_fout_exact_continu_SSO(n, k, N_klant, zekerheid, verdeling)
61
+ benaderd_max = max_fout_benaderd_SSO(n, k, N_klant, zekerheid, verdeling)
62
+
63
+ # Effectieve steekproefomvang/aantal fouten bij de klant (voor de
64
+ # benaderde, continue verdeling).
65
+ n_klant = (n * N_klant) / (n + N_klant)
66
+ k_klant = (n_klant / n) * k
67
+
68
+ x_counts = np.arange(0, N_klant + 1)
69
+ exact_fracties = x_counts / N_klant
70
+
71
+ x_lim = min(1.0, max(exact_max, exact_continu_max, benaderd_max) * 3)
72
+ if x_lim <= 0:
73
+ x_lim = 1.0
74
+ fracties_cont = np.linspace(0, x_lim, 500)
75
+ # De exact-continue dichtheid is alleen gedefinieerd op [0, N_klant]
76
+ # (aantal fouten), dus begrensd tot x_lim in foutfractie-termen.
77
+ tellingen_cont = fracties_cont * N_klant
78
+
79
+ if verdeling == "binomiaal":
80
+ exact_pmf = stats.betabinom.pmf(x_counts, N_klant, k + 1, n - k + 1)
81
+ exact_continu_dichtheid = (
82
+ _betabinom_continu_pdf(tellingen_cont, N_klant, k + 1, n - k + 1) * N_klant
83
+ )
84
+ benaderd_dichtheid = stats.beta.pdf(
85
+ fracties_cont, k_klant + 1, n_klant - k_klant + 1
86
+ )
87
+ exact_label = "Exact (Beta-Binomiaal, discreet)"
88
+ exact_continu_label = "Exact, continu doorgetrokken"
89
+ benaderd_label = "Benadering (Beta)"
90
+ else:
91
+ p_succes = n / (n + N_klant)
92
+ exact_pmf = stats.nbinom.pmf(x_counts, k + 1, p_succes)
93
+ r = k + 1
94
+ exact_continu_dichtheid = (
95
+ np.exp(
96
+ r * np.log(p_succes)
97
+ + tellingen_cont * np.log(1 - p_succes)
98
+ + gammaln(tellingen_cont + r)
99
+ - gammaln(r)
100
+ - gammaln(tellingen_cont + 1)
101
+ )
102
+ * N_klant
103
+ )
104
+ benaderd_dichtheid = stats.gamma.pdf(
105
+ fracties_cont, a=k_klant + 1, scale=1.0 / n_klant
106
+ )
107
+ exact_label = "Exact (Negatief-Binomiaal, discreet)"
108
+ exact_continu_label = "Exact, continu doorgetrokken"
109
+ benaderd_label = "Benadering (Gamma)"
110
+
111
+ # Kansdichtheid per eenheid fractie: de PMF-massa op elk gridpunt
112
+ # i/N_klant omgerekend naar een dichtheid (gridpunten liggen 1/N_klant
113
+ # uit elkaar).
114
+ exact_dichtheid = exact_pmf * N_klant
115
+
116
+ zichtbaar = exact_fracties <= x_lim
117
+
118
+ fig, ax = plt.subplots(figsize=(10, 6))
119
+
120
+ ax.fill_between(
121
+ exact_fracties[zichtbaar],
122
+ exact_dichtheid[zichtbaar],
123
+ step="mid",
124
+ alpha=0.35,
125
+ color="#2980b9",
126
+ )
127
+ ax.plot(
128
+ exact_fracties[zichtbaar],
129
+ exact_dichtheid[zichtbaar],
130
+ drawstyle="steps-mid",
131
+ color="#2980b9",
132
+ linewidth=1.2,
133
+ label=exact_label,
134
+ )
135
+ ax.plot(
136
+ fracties_cont,
137
+ exact_continu_dichtheid,
138
+ color="#1b4f72",
139
+ linestyle=":",
140
+ linewidth=2,
141
+ label=exact_continu_label,
142
+ )
143
+ ax.plot(
144
+ fracties_cont,
145
+ benaderd_dichtheid,
146
+ color="#e67e22",
147
+ linewidth=2,
148
+ label=benaderd_label,
149
+ )
150
+
151
+ ax.axvline(
152
+ exact_max,
153
+ color="#2980b9",
154
+ linestyle="--",
155
+ linewidth=1.5,
156
+ label=f"Max. fout exact ({zekerheid * 100:.0f}%): {nl_getal(exact_max, 4)}",
157
+ )
158
+ ax.axvline(
159
+ exact_continu_max,
160
+ color="#1b4f72",
161
+ linestyle=":",
162
+ linewidth=1.5,
163
+ label=(
164
+ f"Max. fout exact continu ({zekerheid * 100:.0f}%): "
165
+ f"{nl_getal(exact_continu_max, 4)}"
166
+ ),
167
+ )
168
+ ax.axvline(
169
+ benaderd_max,
170
+ color="#e67e22",
171
+ linestyle="--",
172
+ linewidth=1.5,
173
+ label=f"Max. fout benaderd ({zekerheid * 100:.0f}%): {nl_getal(benaderd_max, 4)}",
174
+ )
175
+
176
+ ax.set_xlim(0, x_lim)
177
+ ax.xaxis.set_major_formatter(nl_tick_formatter(3))
178
+ ax.set_xlabel("foutfractie bij de klant")
179
+ ax.set_ylabel("kansdichtheid")
180
+ fig.suptitle(
181
+ "Kanskromme foutfractie bij de klant: exact vs. benaderd",
182
+ fontweight="bold",
183
+ fontsize=13,
184
+ )
185
+ ax.set_title(
186
+ f"n={n}, k={k}, N_klant={N_klant}, zekerheid={nl_getal(zekerheid, 2)}, "
187
+ f"verdeling={verdeling}",
188
+ fontsize=10,
189
+ )
190
+ ax.legend(fontsize=9)
191
+ ax.grid(axis="x", linestyle=":", alpha=0.4)
192
+ fig.tight_layout()
193
+ # Alleen tonen bij een interactieve backend; bij bijv. Streamlit (Agg)
194
+ # geeft plt.show() alleen een onnodige waarschuwing.
195
+ if matplotlib.get_backend().lower() != "agg":
196
+ plt.show()
197
+ return fig
@@ -0,0 +1,160 @@
1
+ import matplotlib
2
+ import matplotlib.pyplot as plt
3
+ import numpy as np
4
+
5
+ from auditstat._formatting import nl_getal, nl_tick_formatter
6
+ from auditstat.sso.max_fout_benaderd_SSO import max_fout_benaderd_SSO
7
+ from auditstat.sso.max_fout_exact_SSO import max_fout_exact_SSO
8
+
9
+ hoofdtitel = (
10
+ "Vergelijking maximale foutfractie van klant SSO op basis van steekproef uit SSO, n, \n"
11
+ "som foutfracties, k, en aantal posten klant, N_klant"
12
+ )
13
+
14
+
15
+ def _nl_param_waarde(naam, waarde):
16
+ """Formatteert een parameterwaarde met Nederlandse notatie: 2
17
+ decimalen voor zekerheid (een fractie), geen decimalen (met
18
+ duizendtal-scheidingsteken) voor de overige (gehele) parameters."""
19
+ return nl_getal(waarde, 2 if naam == "zekerheid" else 0)
20
+
21
+
22
+ def _teken_vergelijking(
23
+ ax, n, k, N_klant, zekerheid, verdeling="binomiaal", met_titel=True
24
+ ):
25
+ """
26
+ Berekent de exacte en benaderde foutfractie en tekent deze op de
27
+ meegegeven Axes. Verwacht precies één lijst/array als input voor
28
+ n, k, N_klant of zekerheid om de x-as te bepalen.
29
+ """
30
+ params = {"n": n, "k": k, "N_klant": N_klant, "zekerheid": zekerheid}
31
+
32
+ # Detecteer welke parameter de vector is.
33
+ var_name = None
34
+ var_vector = None
35
+ for name, val in params.items():
36
+ if isinstance(val, (list, np.ndarray)):
37
+ if var_name is not None:
38
+ raise ValueError("Slechts 1 parameter mag een vector zijn.")
39
+ var_name = name
40
+ var_vector = val
41
+
42
+ if var_name is None:
43
+ raise ValueError("Geef tenminste 1 list/array mee om over te variëren.")
44
+
45
+ exact_vals = []
46
+ benaderd_vals = []
47
+
48
+ for val in var_vector:
49
+ p = params.copy()
50
+ p[var_name] = val
51
+ exact_vals.append(
52
+ max_fout_exact_SSO(p["n"], p["k"], p["N_klant"], p["zekerheid"], verdeling)
53
+ )
54
+ benaderd_vals.append(
55
+ max_fout_benaderd_SSO(
56
+ p["n"], p["k"], p["N_klant"], p["zekerheid"], verdeling
57
+ )
58
+ )
59
+
60
+ # Subtitel bij de plot:
61
+ # vaste parameters, plus de gevarieerde parameter met zijn bereik, en de verdeling.
62
+ vaste_params = {name: val for name, val in params.items() if name != var_name}
63
+ vaste_params_tekst = ", ".join(
64
+ f"{name}={_nl_param_waarde(name, val)}" for name, val in vaste_params.items()
65
+ )
66
+ gevarieerd_tekst = (
67
+ f"{var_name}={_nl_param_waarde(var_name, min(var_vector))}.."
68
+ f"{_nl_param_waarde(var_name, max(var_vector))}"
69
+ )
70
+ subtitel = f"{vaste_params_tekst}; {gevarieerd_tekst}, verdeling: {verdeling}"
71
+
72
+ ax.plot(
73
+ var_vector, exact_vals, label="Exact (Beta-Binomiaal)", marker="o", markersize=4
74
+ )
75
+ ax.plot(
76
+ var_vector,
77
+ benaderd_vals,
78
+ label="Benadering met $ n_{klant} = (n * N_{klant}) / (n + N_{klant}) $ en $ k_{klant} = k * (n_{klant} / n) $",
79
+ linestyle="--",
80
+ marker="x",
81
+ markersize=4,
82
+ )
83
+ if met_titel:
84
+ ax.set_title(
85
+ f"{hoofdtitel}\n{subtitel}",
86
+ fontsize=11,
87
+ )
88
+ else:
89
+ ax.set_title(
90
+ f"{subtitel}",
91
+ fontsize=11,
92
+ )
93
+ ax.set_xlabel(var_name)
94
+ ax.set_ylabel("maximale foutfractie")
95
+ ax.xaxis.set_major_formatter(nl_tick_formatter(2 if var_name == "zekerheid" else 0))
96
+ ax.yaxis.set_major_formatter(nl_tick_formatter(4))
97
+ ax.legend(fontsize=8)
98
+ ax.grid(True, alpha=0.3)
99
+
100
+ return var_name
101
+
102
+
103
+ def plot_max_fout_vergelijking_SSO(n, k, N_klant, zekerheid, verdeling="binomiaal"):
104
+ """
105
+ Plot de exacte en benaderde foutfractie. Verwacht precies één lijst/array als input
106
+ voor n, k, N_klant of zekerheid om de x-as te bepalen.
107
+
108
+ Returns
109
+ -------
110
+ matplotlib.figure.Figure
111
+ """
112
+ fig, ax = plt.subplots(figsize=(10, 6))
113
+ _teken_vergelijking(ax, n, k, N_klant, zekerheid, verdeling, met_titel=True)
114
+ plt.tight_layout()
115
+ # Alleen tonen bij een interactieve backend; bij bijv. Streamlit (Agg)
116
+ # geeft plt.show() alleen een onnodige waarschuwing.
117
+ if matplotlib.get_backend().lower() != "agg":
118
+ plt.show()
119
+ return fig
120
+
121
+
122
+ def plot_max_fout_vergelijking_SSO_overzicht(parameter_sets):
123
+ """
124
+ Combineert meerdere aanroepen van plot_max_fout_vergelijking_SSO in één
125
+ figuur met een 2x2-raster subplots.
126
+
127
+ Parameters
128
+ ----------
129
+ parameter_sets : list[dict]
130
+ Lijst van precies 4 kwargs-dictionaries, elk met dezelfde sleutels
131
+ als plot_max_fout_vergelijking_SSO (n, k, N_klant, zekerheid en
132
+ optioneel verdeling). Per dictionary moet precies één van
133
+ n/k/N_klant/zekerheid een lijst/array zijn.
134
+ titel : str, optioneel
135
+ Gezamenlijke titel boven de 4 subplots.
136
+
137
+ Returns
138
+ -------
139
+ matplotlib.figure.Figure
140
+ De figuur met de 4 subplots, zodat deze desgewenst verder bewerkt
141
+ of opgeslagen kan worden door de aanroeper.
142
+ """
143
+ if len(parameter_sets) != 4:
144
+ raise ValueError(
145
+ "Verwacht precies 4 parametersets voor het 2x2-overzicht, "
146
+ f"kreeg er {len(parameter_sets)}."
147
+ )
148
+
149
+ fig, axes = plt.subplots(2, 2, figsize=(16, 10))
150
+ for ax, params in zip(axes.flat, parameter_sets, strict=True):
151
+ _teken_vergelijking(ax, **params, met_titel=False)
152
+
153
+ fig.suptitle(hoofdtitel, fontsize=14)
154
+
155
+ plt.tight_layout()
156
+ # Alleen tonen bij een interactieve backend; bij bijv. Streamlit (Agg)
157
+ # geeft plt.show() alleen een onnodige waarschuwing.
158
+ if matplotlib.get_backend().lower() != "agg":
159
+ plt.show()
160
+ return fig
@@ -0,0 +1,137 @@
1
+ import matplotlib
2
+ import matplotlib.pyplot as plt
3
+ import numpy as np
4
+ from scipy.integrate import trapezoid
5
+
6
+ from auditstat._formatting import nl_getal, nl_getal_variabel, nl_tick_formatter
7
+ from auditstat.sso.max_fout_heterogeen_SSO import (
8
+ _kwantiel_van_theta_posterior,
9
+ _posterior_theta_klant_binomiaal,
10
+ _posterior_theta_klant_poisson,
11
+ )
12
+
13
+
14
+ def _genormaliseerde_dichtheid(theta_grid, dichtheid_ongenormaliseerd):
15
+ """Normaliseert een dichtheid op een vast grid zodat de oppervlakte
16
+ eronder (via trapeziumregel) gelijk is aan 1."""
17
+ oppervlakte = trapezoid(dichtheid_ongenormaliseerd, theta_grid)
18
+ return dichtheid_ongenormaliseerd / oppervlakte
19
+
20
+
21
+ def plot_posterior_heterogeen_SSO(
22
+ n, k, f_waarden, zekerheid=0.95, verdeling="binomiaal", aantal_theta=2001
23
+ ):
24
+ """
25
+ Vergelijkt de posterior-dichtheid van de foutkans bij een SSO-klant
26
+ onder het heterogeniteitsmodel (zie max_fout_heterogeen_SSO), voor
27
+ een reeks waarden van f (het relatieve aandeel van de klant in de
28
+ totale SSO-populatie), met de posterior onder het bestaande
29
+ uitwisselbare model (max_fout_exact_SSO /
30
+ max_fout_exact_continu_SSO). Dat laatste model gaat impliciet uit
31
+ van f = 1: het projecteert de SSO-brede schatting zonder correctie
32
+ op elke klant, ongeacht diens werkelijke omvang.
33
+
34
+ Het uitwisselbare model levert een vaste, van f onafhankelijke
35
+ posterior op theta_klant op (Beta(k + 1, n - k + 1) resp. een op
36
+ [0, 1] getrunceerde Gamma(k + 1, n)). Het heterogene model levert
37
+ voor elke f-waarde een eigen, doorgaans vlakkere posterior op, die
38
+ voor kleinere f dichter bij de vlakke prior komt te liggen: hoe
39
+ kleiner het aandeel van de klant in de SSO-brede steekproef, hoe
40
+ minder klant-specifieke informatie die steekproef bevat.
41
+
42
+ Parameters
43
+ ----------
44
+ n, k : int
45
+ Omvang en aantal fouten in de SSO-brede steekproef.
46
+ f_waarden : array-like van float
47
+ Reeks te vergelijken waarden van f (relatieve omvang van de
48
+ klant binnen de totale SSO-populatie), elk tussen 0 en 1.
49
+ zekerheid : float, standaard 0.95
50
+ Zekerheid waarvoor de verticale kwantiellijnen worden getekend.
51
+ verdeling : {"binomiaal", "poisson"}, standaard "binomiaal"
52
+ aantal_theta : int, standaard 2001
53
+ Resolutie van het grid voor theta op [0, 1].
54
+
55
+ Returns
56
+ -------
57
+ matplotlib.figure.Figure
58
+ """
59
+ if verdeling not in ("binomiaal", "poisson"):
60
+ raise ValueError("Kies 'binomiaal' of 'poisson'")
61
+
62
+ f_waarden = np.atleast_1d(np.asarray(f_waarden, dtype=float))
63
+ if f_waarden.size == 0:
64
+ raise ValueError("f_waarden mag niet leeg zijn.")
65
+ if np.any((f_waarden < 0) | (f_waarden > 1)):
66
+ raise ValueError("Elke waarde in f_waarden moet tussen 0 en 1 liggen.")
67
+ if not (0 < zekerheid < 1):
68
+ raise ValueError("zekerheid moet tussen 0 en 1 liggen.")
69
+
70
+ theta_grid = np.linspace(0.0, 1.0, aantal_theta)
71
+ posterior_fn = (
72
+ _posterior_theta_klant_binomiaal
73
+ if verdeling == "binomiaal"
74
+ else _posterior_theta_klant_poisson
75
+ )
76
+
77
+ # Het uitwisselbare model komt overeen met f = 1 in het heterogene
78
+ # model (zie max_fout_heterogeen_SSO voor de verificatie hiervan).
79
+ dichtheid_ongenorm_uitwisselbaar = posterior_fn(n, k, 1.0, theta_grid)
80
+ dichtheid_uitwisselbaar = _genormaliseerde_dichtheid(
81
+ theta_grid, dichtheid_ongenorm_uitwisselbaar
82
+ )
83
+ kwantiel_uitwisselbaar = _kwantiel_van_theta_posterior(
84
+ theta_grid, dichtheid_ongenorm_uitwisselbaar, zekerheid
85
+ )
86
+
87
+ fig, ax = plt.subplots(figsize=(10, 6))
88
+
89
+ ax.plot(
90
+ theta_grid,
91
+ dichtheid_uitwisselbaar,
92
+ color="black",
93
+ linewidth=2.5,
94
+ label=(
95
+ f"Uitwisselbaar model (f = 1): {zekerheid * 100:.0f}%-kwantiel = "
96
+ f"{nl_getal(kwantiel_uitwisselbaar, 4)}"
97
+ ),
98
+ )
99
+ ax.axvline(kwantiel_uitwisselbaar, color="black", linestyle="--", linewidth=1.2)
100
+
101
+ kleuren = plt.cm.viridis(np.linspace(0.15, 0.85, len(f_waarden)))
102
+ for f, kleur in zip(f_waarden, kleuren, strict=True):
103
+ dichtheid_ongenorm = posterior_fn(n, k, f, theta_grid)
104
+ dichtheid = _genormaliseerde_dichtheid(theta_grid, dichtheid_ongenorm)
105
+ kwantiel = _kwantiel_van_theta_posterior(
106
+ theta_grid, dichtheid_ongenorm, zekerheid
107
+ )
108
+ ax.plot(
109
+ theta_grid,
110
+ dichtheid,
111
+ color=kleur,
112
+ linewidth=1.8,
113
+ label=(
114
+ f"Heterogeen model (f = {nl_getal_variabel(f)}): "
115
+ f"{zekerheid * 100:.0f}%-kwantiel = {nl_getal(kwantiel, 4)}"
116
+ ),
117
+ )
118
+ ax.axvline(kwantiel, color=kleur, linestyle="--", linewidth=1.0)
119
+
120
+ ax.set_xlim(0, 1)
121
+ ax.xaxis.set_major_formatter(nl_tick_formatter(1))
122
+ ax.set_xlabel("foutkans/-fractie bij de klant (theta_klant)")
123
+ ax.set_ylabel("kansdichtheid")
124
+ fig.suptitle(
125
+ "Posterior foutkans bij de klant: uitwisselbaar vs. heterogeen model",
126
+ fontweight="bold",
127
+ fontsize=13,
128
+ )
129
+ ax.set_title(f"n={n}, k={k}, verdeling={verdeling}", fontsize=10)
130
+ ax.legend(fontsize=8.5)
131
+ ax.grid(axis="x", linestyle=":", alpha=0.4)
132
+ fig.tight_layout()
133
+ # Alleen tonen bij een interactieve backend; bij bijv. Streamlit (Agg)
134
+ # geeft plt.show() alleen een onnodige waarschuwing.
135
+ if matplotlib.get_backend().lower() != "agg":
136
+ plt.show()
137
+ return fig
@@ -0,0 +1,106 @@
1
+ # Pas de diverse functies van auditstat.SSO toe in 1 script.
2
+
3
+ import numpy as np
4
+
5
+ from auditstat.sso.max_fout_benaderd_SSO import max_fout_benaderd_SSO
6
+ from auditstat.sso.max_fout_exact_SSO import max_fout_exact_SSO
7
+ from auditstat.sso.plot_kanskromme_SSO import plot_kanskromme_SSO
8
+ from auditstat.sso.plot_max_fout_vergelijking_SSO import (
9
+ # plot_max_fout_vergelijking_SSO,
10
+ plot_max_fout_vergelijking_SSO_overzicht,
11
+ )
12
+ from auditstat.sso.plot_posterior_heterogeen_SSO import plot_posterior_heterogeen_SSO
13
+ from auditstat.sso.simuleer_SSO import simuleer_SSO
14
+
15
+
16
+ def script_SSO():
17
+ n_basis = 200
18
+ k_basis = 0
19
+ N_klant_basis = 1500
20
+ zekerheid_basis = 0.95
21
+ iteraties = 10_000_000
22
+ verdeling = "binomiaal"
23
+
24
+ print("--- 1. Puntberekening ---")
25
+ print(
26
+ f"Instellingen: n={n_basis}, k={k_basis}, N_klant={N_klant_basis}, Zekerheid={zekerheid_basis}"
27
+ )
28
+
29
+ exact = max_fout_exact_SSO(
30
+ n_basis, k_basis, N_klant_basis, zekerheid_basis, verdeling
31
+ )
32
+ benaderd = max_fout_benaderd_SSO(
33
+ n_basis, k_basis, N_klant_basis, zekerheid_basis, verdeling
34
+ )
35
+
36
+ print(f"Exacte methode: {exact:.4f} ({exact * 100:.2f}%)")
37
+ print(f"Benaderingsmethode: {benaderd:.4f} ({benaderd * 100:.2f}%)")
38
+
39
+ print("\n--- 2. Validatie via Simulatie ---")
40
+ print(
41
+ f"Instellingen: n={n_basis}, k={k_basis}, N_klant={N_klant_basis}, Zekerheid={zekerheid_basis}"
42
+ )
43
+ print(f"Simuleren over {iteraties} iteraties... Dit duurt enkele seconden.")
44
+ sim = simuleer_SSO(
45
+ n_basis, k_basis, N_klant_basis, zekerheid_basis, verdeling, iteraties=iteraties
46
+ )
47
+
48
+ print(f"Simulatie grens (discreet, empirisch): {sim:.4f} ({sim * 100:.2f}%)")
49
+ print("Let op: De simulatie geeft uiteraard een discrete fractie (bijv. 4/150).")
50
+ print(
51
+ "De analytische exacte methode trekt dit door de interpolatie-logica juist continu door."
52
+ )
53
+
54
+ print("\n--- 3. Visuele vergelijking ---")
55
+ n_basis_vec = np.arange(10, 1001, 10)
56
+ k_basis_vec = np.arange(0, n_basis, 1)
57
+ zekerheid_vec = np.arange(0.6, 0.99, 0.01)
58
+ N_klant_vec = np.arange(10, 1001, 10)
59
+ plot_max_fout_vergelijking_SSO_overzicht(
60
+ [
61
+ dict(
62
+ n=n_basis_vec,
63
+ k=k_basis,
64
+ N_klant=N_klant_basis,
65
+ zekerheid=zekerheid_basis,
66
+ verdeling=verdeling,
67
+ ),
68
+ dict(
69
+ n=n_basis,
70
+ k=k_basis_vec,
71
+ N_klant=500,
72
+ zekerheid=zekerheid_basis,
73
+ verdeling=verdeling,
74
+ ),
75
+ dict(
76
+ n=n_basis,
77
+ k=k_basis,
78
+ N_klant=N_klant_vec,
79
+ zekerheid=zekerheid_basis,
80
+ verdeling=verdeling,
81
+ ),
82
+ dict(
83
+ n=n_basis,
84
+ k=k_basis,
85
+ N_klant=N_klant_basis,
86
+ zekerheid=zekerheid_vec,
87
+ verdeling=verdeling,
88
+ ),
89
+ ],
90
+ )
91
+
92
+ print("\n--- 4. Kanskromme exact vs. benaderd ---")
93
+ plot_kanskromme_SSO(n_basis, k_basis, N_klant_basis, zekerheid_basis, verdeling)
94
+
95
+ print("\n--- 5. Uitwisselbaar vs. heterogeen model, over een reeks f-waarden ---")
96
+ plot_posterior_heterogeen_SSO(
97
+ n_basis,
98
+ k_basis,
99
+ f_waarden=[0.5, 0.05, 0.005],
100
+ zekerheid=zekerheid_basis,
101
+ verdeling=verdeling,
102
+ )
103
+
104
+
105
+ if __name__ == "__main__":
106
+ script_SSO()
@@ -0,0 +1,28 @@
1
+ import numpy as np
2
+
3
+
4
+ def simuleer_SSO(
5
+ n, k, N_klant, zekerheid=0.95, verdeling="binomiaal", iteraties=500000
6
+ ):
7
+ """
8
+ Controleert max_fout_SSO via Monte Carlo simulatie.
9
+ """
10
+ if verdeling == "binomiaal":
11
+ # Trek p uit de posterior: Beta(k+1, n-k+1)
12
+ p_sim = np.random.beta(k + 1, n - k + 1, iteraties)
13
+ # Genereer fouten bij de klant gegeven de getrokken p's
14
+ k_klant_sim = np.random.binomial(N_klant, p_sim)
15
+
16
+ elif verdeling == "poisson":
17
+ # Trek p uit de posterior Gamma (scale = 1/n)
18
+ p_sim = np.random.gamma(k + 1, 1.0 / n, iteraties)
19
+ k_klant_sim = np.random.poisson(N_klant * p_sim)
20
+
21
+ else:
22
+ raise ValueError("Kies 'binomiaal' of 'poisson'")
23
+
24
+ # Zoek het empirische kwantiel van de foutfractie bij de klant
25
+ fracties = k_klant_sim / N_klant
26
+ gesimuleerde_grens = np.percentile(fracties, zekerheid * 100)
27
+
28
+ return gesimuleerde_grens