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.
- auditstat/__init__.py +6 -0
- auditstat/_formatting.py +32 -0
- auditstat/sso/__init__.py +6 -0
- auditstat/sso/evalueer_SSO_klant_gestratificeerd.py +56 -0
- auditstat/sso/max_fout_benaderd_SSO.py +19 -0
- auditstat/sso/max_fout_exact_SSO.py +48 -0
- auditstat/sso/max_fout_exact_continu_SSO.py +107 -0
- auditstat/sso/max_fout_heterogeen_SSO.py +164 -0
- auditstat/sso/moment_match_SSO.py +110 -0
- auditstat/sso/n_klant_k_klant_SSO.py +38 -0
- auditstat/sso/plot_kanskromme_SSO.py +197 -0
- auditstat/sso/plot_max_fout_vergelijking_SSO.py +160 -0
- auditstat/sso/plot_posterior_heterogeen_SSO.py +137 -0
- auditstat/sso/script_SSO.py +106 -0
- auditstat/sso/simuleer_SSO.py +28 -0
- auditstat/sso/strata_SSO_klant.py +116 -0
- auditstat/stratified/__init__.py +19 -0
- auditstat/stratified/analyseer_klimheuristiek.py +319 -0
- auditstat/stratified/eval_stratified.py +925 -0
- auditstat/stratified/plan_stratified.py +574 -0
- auditstat/stratified/plot_kanskromme.py +149 -0
- auditstat/stratified/utils.py +268 -0
- auditstat/stratified/valideer_granulariteit.py +171 -0
- auditstat-0.1.9.dist-info/METADATA +651 -0
- auditstat-0.1.9.dist-info/RECORD +28 -0
- auditstat-0.1.9.dist-info/WHEEL +5 -0
- auditstat-0.1.9.dist-info/licenses/LICENSE +287 -0
- auditstat-0.1.9.dist-info/top_level.txt +1 -0
|
@@ -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
|