Bauteilprüfung im Labor¶
Ein Beispielnotebook zum Buch Das Richtige als Nächstes, Kapitel 6.
Das Notebook spielt den ersten Laborversuch von Kellbrink & Sohn durch. Die Daten sind erfunden. Echte Bauteilbilder gibt es hier nicht. Stattdessen arbeitet das Notebook mit drei Kennwerten, wie sie eine Bildauswertung je Bauteil liefern könnte. So bleibt der Versuch klein, und die Fragen sind dieselben wie mit Bildern: Wie viele kritische Fehler rutschen durch, und wie viele gute Teile werden zu Unrecht aussortiert?
Sie können jede Zelle einzeln ausführen (Umschalt + Enter) und Zahlen verändern, um zu sehen, was passiert. Das Notebook läuft ohne Installation zum Beispiel in Google Colab: Datei hochladen und im Menü „Laufzeit“ den Punkt „Alle ausführen“ wählen.
Material zum Buch, Stand November 2026. Die aktuelle Fassung liegt immer unter kiwi-strategie.de/material/.
1. Die Laborhypothese¶
Bevor wir rechnen, halten wir fest, was wir herausfinden wollen. Das ist die Tabelle aus Abschnitt 6.2, ausgefüllt für diesen Versuch:
| Feld | Für diesen Versuch |
|---|---|
| Aufgabe | Kritische Oberflächenfehler erkennen, bevor ein Teil das Werk verlässt |
| Hypothese | Ein einfaches Modell übersieht nicht mehr kritische Fehler als die bisherige Prüfung, bei einer vertretbaren Zahl von Fehlalarmen |
| Vergleichsgrundlage | Die bisherige Sichtprüfung an denselben Teilen |
| Daten | Eine Produktvariante, 40.000 beurteilte Teile, drei Kennwerte je Teil |
| Messgröße | Schlupf (übersehene kritische Fehler) und Fehlalarme (gute Teile, die aussortiert werden) |
| Testumfang | Die letzten 12.000 Teile |
| Abbruchkriterium | Das Modell übersieht mehr Fehler als die bisherige Prüfung, oder es löst bei mehr als 3 Prozent der guten Teile Alarm aus |
| Verantwortung | Die Qualitätsfachleute bewerten das Ergebnis, die Geschäftsleitung entscheidet über den nächsten Schritt |
Die 3 Prozent sind eine Annahme für dieses Beispiel. Im echten Versuch legen die Fachleute beide Grenzen fest, bevor das erste Ergebnis vorliegt.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
MAX_FEHLALARMRATE = 0.03 # höchstens 3 % der guten Teile dürfen zu Unrecht aussortiert werden
SCHWELLE = 0.02 # ab dieser geschätzten Fehlerwahrscheinlichkeit schlägt das Modell Alarm
rng = np.random.default_rng(7) # fester Startwert, damit alle dasselbe Ergebnis sehen
2. Erfundene, aber plausible Daten¶
Von tausend Teilen haben im Mittel fünf einen kritischen Fehler. Je Teil gibt es drei Kennwerte: den stärksten Kontrast auf der Oberfläche, die Abweichung der Kante vom Sollmaß in Tausendstel Millimetern und die mittlere Helligkeit der Aufnahme. Fehlerhafte Teile haben im Mittel mehr Kontrast und eine größere Kantenabweichung, aber die Bereiche überlappen. Die Helligkeit hängt nur von der Aufnahme ab, nicht vom Fehler.
Dazu kommt die bisherige Sichtprüfung. Sie übersieht in diesem Beispiel etwa jeden achten kritischen Fehler und sortiert etwa eines von hundert guten Teilen zu Unrecht aus. Auch das ist eine Annahme.
def teile_erzeugen(anzahl, helligkeit_mittel=100.0):
fehler = rng.random(anzahl) < 0.005
kontrast = rng.normal(10, 2.5, anzahl) + fehler * rng.normal(9, 3, anzahl)
kante = np.abs(rng.normal(0, 30, anzahl)) + fehler * np.abs(rng.normal(60, 30, anzahl))
helligkeit = rng.normal(helligkeit_mittel, 4, anzahl)
# die Kamera misst Kontrast nicht unabhängig vom Licht: hellere Aufnahme, etwas mehr Kontrast
kontrast = kontrast * helligkeit / 100
bisher = np.where(fehler, rng.random(anzahl) > 0.12, rng.random(anzahl) < 0.01)
return pd.DataFrame({"kontrast": kontrast.round(2), "kantenabweichung": kante.round(0),
"helligkeit": helligkeit.round(1), "pruefung_bisher": bisher.astype(int),
"fehler": fehler.astype(int)})
daten = teile_erzeugen(40_000)
print(f"{len(daten)} Teile, davon {daten['fehler'].sum()} mit kritischem Fehler")
daten.head()
40000 Teile, davon 181 mit kritischem Fehler
| kontrast | kantenabweichung | helligkeit | pruefung_bisher | fehler | |
|---|---|---|---|---|---|
| 0 | 9.31 | 10.0 | 97.8 | 0 | 0 |
| 1 | 9.44 | 11.0 | 91.5 | 0 | 0 |
| 2 | 8.38 | 48.0 | 100.4 | 0 | 0 |
| 3 | 9.04 | 43.0 | 100.3 | 0 | 0 |
| 4 | 8.89 | 12.0 | 109.4 | 0 | 0 |
3. Training und Test sauber trennen¶
Das Modell lernt aus den ersten 28.000 Teilen. Die letzten 12.000 bleiben unberührt und dienen allein dem Vergleich. Die Spalte fehler ist die fachliche Referenz. Im echten Versuch stammt sie von zwei erfahrenen Fachleuten, die unabhängig voneinander urteilen.
training = daten.iloc[:28_000]
test = daten.iloc[28_000:].copy()
print(f"Training: {len(training)} Teile, {training['fehler'].sum()} kritische Fehler")
print(f"Test: {len(test)} Teile, {test['fehler'].sum()} kritische Fehler")
Training: 28000 Teile, 116 kritische Fehler Test: 12000 Teile, 65 kritische Fehler
Im Test stecken nur einige Dutzend Fehler. Das ist die eigentliche Stichprobe dieses Versuchs, nicht die 12.000 Teile. Wer seltene Fehler sucht, hat immer weniger Beispiele, als die Datenmenge vermuten lässt (Abschnitt 6.3).
4. Zwei Vergleichsgrundlagen¶
Zuerst die bequemste aller Regeln: jedes Teil für gut erklären. Danach die bisherige Sichtprüfung.
def auswerten(name, alarm, wahr):
alarm = np.asarray(alarm).astype(bool)
wahr = np.asarray(wahr).astype(bool)
return {"Verfahren": name,
"Trefferquote gesamt": f"{(alarm == wahr).mean():.1%}",
"erkannte Fehler": int((alarm & wahr).sum()),
"Schlupf": int((~alarm & wahr).sum()),
"Fehlalarme": int((alarm & ~wahr).sum()),
"Fehlalarmrate": f"{(alarm & ~wahr).sum() / (~wahr).sum():.1%}"}
zeilen = [auswerten("Alles gut", np.zeros(len(test)), test["fehler"]),
auswerten("Bisherige Sichtprüfung", test["pruefung_bisher"], test["fehler"])]
pd.DataFrame(zeilen)
| Verfahren | Trefferquote gesamt | erkannte Fehler | Schlupf | Fehlalarme | Fehlalarmrate | |
|---|---|---|---|---|---|---|
| 0 | Alles gut | 99.5% | 0 | 65 | 0 | 0.0% |
| 1 | Bisherige Sichtprüfung | 99.0% | 55 | 10 | 105 | 0.9% |
Die Regel „alles gut“ hat fast immer recht und findet keinen einzigen Fehler. Die Trefferquote über alle Teile sagt bei seltenen Fehlern fast nichts (Abschnitt 2.5). Deshalb zählt dieser Versuch Schlupf und Fehlalarme getrennt, und die Vergleichsgrundlage ist die bisherige Sichtprüfung.
5. Das Modell¶
Ein einfaches Verfahren genügt für den ersten Versuch: eine logistische Regression. Sie schätzt aus Kontrast und Kantenabweichung für jedes Teil eine Fehlerwahrscheinlichkeit. Liegt sie über der Schwelle, schlägt das Modell Alarm.
MERKMALE = ["kontrast", "kantenabweichung"]
modell = LogisticRegression(max_iter=2000).fit(training[MERKMALE], training["fehler"])
test["wahrscheinlichkeit"] = modell.predict_proba(test[MERKMALE])[:, 1]
test["alarm_modell"] = (test["wahrscheinlichkeit"] >= SCHWELLE).astype(int)
zeilen.append(auswerten(f"Modell, Schwelle {SCHWELLE}", test["alarm_modell"], test["fehler"]))
ergebnis = pd.DataFrame(zeilen)
ergebnis
| Verfahren | Trefferquote gesamt | erkannte Fehler | Schlupf | Fehlalarme | Fehlalarmrate | |
|---|---|---|---|---|---|---|
| 0 | Alles gut | 99.5% | 0 | 65 | 0 | 0.0% |
| 1 | Bisherige Sichtprüfung | 99.0% | 55 | 10 | 105 | 0.9% |
| 2 | Modell, Schwelle 0.02 | 99.1% | 55 | 10 | 100 | 0.8% |
6. Die Entscheidung am Gate¶
wahr = test["fehler"].astype(bool)
schlupf_bisher = int((~test["pruefung_bisher"].astype(bool) & wahr).sum())
schlupf_modell = int((~test["alarm_modell"].astype(bool) & wahr).sum())
rate_modell = (test["alarm_modell"].astype(bool) & ~wahr).sum() / (~wahr).sum()
print(f"Schlupf bisherige Prüfung: {schlupf_bisher} von {wahr.sum()} kritischen Fehlern")
print(f"Schlupf Modell: {schlupf_modell} von {wahr.sum()} kritischen Fehlern")
print(f"Fehlalarmrate Modell: {rate_modell:.1%} (Grenze: {MAX_FEHLALARMRATE:.0%})")
print()
if schlupf_modell <= schlupf_bisher and rate_modell <= MAX_FEHLALARMRATE:
print("Die Hypothese hält. Ein nächster Schritt ist gerechtfertigt, wenn die Qualitätsfachleute zustimmen.")
else:
print("Mindestens eine Grenze ist verletzt. Nachschärfen, vereinfachen oder bewusst anhalten.")
Schlupf bisherige Prüfung: 10 von 65 kritischen Fehlern Schlupf Modell: 10 von 65 kritischen Fehlern Fehlalarmrate Modell: 0.8% (Grenze: 3%) Die Hypothese hält. Ein nächster Schritt ist gerechtfertigt, wenn die Qualitätsfachleute zustimmen.
7. Die Schwelle ist eine fachliche Entscheidung¶
Das Modell liefert eine Wahrscheinlichkeit. Ab wann daraus ein Alarm wird, legt ein Mensch fest. Eine niedrige Schwelle fängt mehr Fehler und sortiert mehr gute Teile aus. Eine hohe Schwelle schont die guten Teile und lässt mehr Fehler durch. Die Tabelle und die Grafik zeigen diesen Tausch.
schwellen = [0.005, 0.01, 0.02, 0.05, 0.10, 0.20, 0.50]
tausch = pd.DataFrame([{
"Schwelle": s,
"Schlupf": int((~(test["wahrscheinlichkeit"] >= s) & wahr).sum()),
"Fehlalarme": int(((test["wahrscheinlichkeit"] >= s) & ~wahr).sum()),
"Fehlalarmrate": f"{((test['wahrscheinlichkeit'] >= s) & ~wahr).sum() / (~wahr).sum():.1%}",
} for s in schwellen])
tausch
| Schwelle | Schlupf | Fehlalarme | Fehlalarmrate | |
|---|---|---|---|---|
| 0 | 0.005 | 5 | 258 | 2.2% |
| 1 | 0.010 | 7 | 166 | 1.4% |
| 2 | 0.020 | 10 | 100 | 0.8% |
| 3 | 0.050 | 13 | 54 | 0.5% |
| 4 | 0.100 | 13 | 30 | 0.3% |
| 5 | 0.200 | 15 | 17 | 0.1% |
| 6 | 0.500 | 18 | 8 | 0.1% |
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(tausch["Fehlalarme"], tausch["Schlupf"], marker="o", color="black")
for _, z in tausch.iterrows():
ax.annotate(f"{z['Schwelle']}", (z["Fehlalarme"], z["Schlupf"]), textcoords="offset points", xytext=(6, 6))
fehlalarme_bisher = int((test["pruefung_bisher"].astype(bool) & ~wahr).sum())
ax.scatter([fehlalarme_bisher], [schlupf_bisher], marker="s", s=70, label="bisherige Sichtprüfung")
ax.set_xlabel("Fehlalarme (gute Teile aussortiert)")
ax.set_ylabel("Schlupf (kritische Fehler übersehen)")
ax.set_title("Jede Schwelle tauscht Schlupf gegen Fehlalarme")
ax.legend()
plt.tight_layout()
plt.show()
Und die Teile, bei denen Modell und Referenz am deutlichsten auseinanderliegen: Fehler, die das Modell für harmlos hielt. Genau über diese Teile lohnt das Gespräch mit den Qualitätsfachleuten.
(test[test["fehler"] == 1]
.sort_values("wahrscheinlichkeit")
[["kontrast", "kantenabweichung", "helligkeit", "pruefung_bisher", "wahrscheinlichkeit"]]
.head(8))
| kontrast | kantenabweichung | helligkeit | pruefung_bisher | wahrscheinlichkeit | |
|---|---|---|---|---|---|
| 31873 | 8.69 | 42.0 | 100.1 | 1 | 0.000004 |
| 30899 | 13.17 | 43.0 | 95.8 | 1 | 0.000878 |
| 34312 | 9.02 | 102.0 | 96.9 | 1 | 0.001124 |
| 35084 | 12.97 | 52.0 | 93.9 | 1 | 0.001533 |
| 30432 | 11.90 | 73.0 | 101.8 | 1 | 0.002727 |
| 30193 | 17.17 | 12.0 | 95.4 | 0 | 0.006820 |
| 28342 | 13.92 | 60.0 | 99.3 | 1 | 0.009675 |
| 37856 | 12.98 | 77.0 | 95.6 | 1 | 0.014062 |
8. Gegenprobe: Die Kamera wird getauscht¶
In Kapitel 7 tauscht Kellbrink & Sohn die Kamera. Die neue Kamera liefert hellere Aufnahmen. Die Teile sind dieselben wie vorher, die Fehlerquote auch. Das Modell bleibt unverändert.
neu = teile_erzeugen(12_000, helligkeit_mittel=112.0)
neu["wahrscheinlichkeit"] = modell.predict_proba(neu[MERKMALE])[:, 1]
alarm_neu = neu["wahrscheinlichkeit"] >= SCHWELLE
pd.DataFrame([auswerten("Modell, alte Kamera", test["alarm_modell"], test["fehler"]),
auswerten("Modell, neue Kamera", alarm_neu, neu["fehler"])])
| Verfahren | Trefferquote gesamt | erkannte Fehler | Schlupf | Fehlalarme | Fehlalarmrate | |
|---|---|---|---|---|---|---|
| 0 | Modell, alte Kamera | 99.1% | 55 | 10 | 100 | 0.8% |
| 1 | Modell, neue Kamera | 96.6% | 68 | 2 | 401 | 3.4% |
Die Fehlalarmrate steigt deutlich und überschreitet die vereinbarte Grenze, obwohl sich an den Teilen nichts geändert hat. Das Modell hat gelernt, was Kontrast unter dem alten Licht bedeutet. Ein Blick auf die mittlere Helligkeit hätte die Veränderung sofort gezeigt. Deshalb gehört zur Überwachung im Betrieb nicht nur das Ergebnis, sondern auch die Eingabe (Abschnitt 7.4).
print(f"Mittlere Helligkeit alte Kamera: {test['helligkeit'].mean():.1f}")
print(f"Mittlere Helligkeit neue Kamera: {neu['helligkeit'].mean():.1f}")
Mittlere Helligkeit alte Kamera: 100.0 Mittlere Helligkeit neue Kamera: 112.0
9. Zum Weiterprobieren¶
- Setzen Sie
SCHWELLEauf 0.05. Was würde das für die Entscheidung am Gate bedeuten? - Nehmen Sie
"kantenabweichung"aus der ListeMERKMALE. Wie verändert sich der Schlupf? - Ändern Sie den Startwert in
default_rng(7)auf eine andere Zahl und führen Sie alles neu aus. Wie stark schwankt der Schlupf, wenn im Test nur einige Dutzend Fehler stecken?
Halten Sie am Ende in wenigen Sätzen fest, was entschieden wurde, warum und was als Nächstes geschieht. Das ist das Entscheidungsprotokoll.
Wichtig: Die Daten hier sind erfunden und deshalb gutmütig. Echte Daten sind lückenhafter, und genau das macht ein echtes Laborergebnis wertvoll.
10. Was dieser Versuch nicht zeigt¶
Ein ehrliches Laborergebnis nennt seine Grenzen. Für dieses Notebook sind es vier.
- Kennwerte sind keine Bilder. Ein Modell, das mit Bildern arbeitet, muss die Merkmale erst selbst finden. Dieses Notebook überspringt den Schritt und zeigt nur, wie man das Ergebnis bewertet.
- Die Referenz ist hier fehlerfrei. Im echten Versuch sind sich auch erfahrene Fachleute nicht immer einig. Die Grenzfälle sind dann kein Störfaktor, sondern der wertvollste Teil des Gesprächs.
- Wenige Fehler, große Unsicherheit. Ein Unterschied von zwei oder drei übersehenen Fehlern kann Zufall sein. Aufgabe 3 zeigt, wie stark das Ergebnis schwankt.
- Fehlalarme und Schlupf kosten nicht dasselbe. Was ein übersehener Fehler beim Kunden kostet und was ein zu Unrecht aussortiertes Teil kostet, steht in keiner Kennzahl dieses Notebooks.
Keine dieser Grenzen macht den Versuch wertlos. Sie gehören ins Entscheidungsprotokoll, damit der nächste Schritt weiß, was noch offen ist.