aiMOOC

Daten- und Prozessanalyse im Technikbetrieb – Analyseschritte reproduzierbar dokumentieren

QR-Code

Daten- und Prozessanalyse im Technikbetrieb – Analyseschritte reproduzierbar dokumentieren

Kurzbeschreibung: In diesem aiMOOC lernst Du an einem fiktiven Technikbetrieb, wie Du Datenversion, Code und Auswertung so dokumentierst, dass eine andere Person dieselbe Analyse lokal wiederholen kann. Du arbeitest nur mit fiktiven Daten und einer lokalen Testumgebung.

Zielgruppe: Ausbildung in technischen, mechatronischen, elektrotechnischen, informationstechnischen oder produktionstechnischen Berufen.

Leitfrage: Wie wird aus einer Messwertdatei eine nachvollziehbare Analyse, deren Datenstand, Programmcode und Ergebnis eindeutig zusammengehören?

Einleitung

Im Technikbetrieb entstehen Messwerte, Zustandsdaten und Prozesszeiten. Eine Auswertung ist erst dann gut nachvollziehbar, wenn dokumentiert ist:

Datenversion: Welche konkrete Datendatei wurde verwendet?
Versionsverwaltung: Welcher Code-Stand erzeugte das Ergebnis?
Auswertung: Welche Kennzahlen, Regeln und Grafiken entstanden?
Reproduzierbarkeit: Kann eine zweite Person denselben Ablauf lokal erneut ausführen?

Sicherheitsregel für diesen Kurs: Du arbeitest ausschließlich in einem lokalen Übungsordner mit fiktiven Daten. Keine Verbindung zu fremden Netzen, Produktivanlagen, SPS-Systemen, Zugangsdaten, Kundendaten oder nicht ausdrücklich freigegebenen Diensten.

Ausbildungsfall: Kühlstrecke T-17

Du bist in einem fiktiven Ausbildungsbetrieb eingesetzt. Eine Kühlstrecke liefert Temperatur- und Taktzeitwerte. Die Schichtleitung möchte wissen, ob sich ab 09:15 Uhr auffällige Werte zeigen.

Auftrag: Speichere den Datenstand, analysiere ihn mit lokalem Python-Code, erzeuge eine Grafik und dokumentiere den gesamten Lauf.

Die Daten sind vollständig erfunden.

zeit;maschine;temp_c;takt_s;status
08:00;M1;61.8;12.2;OK
08:15;M1;62.4;12.0;OK
08:30;M1;63.1;11.9;OK
08:45;M1;64.0;12.1;OK
09:00;M1;65.2;12.3;OK
09:15;M1;69.8;13.0;PRUEFEN
09:30;M1;71.2;13.8;PRUEFEN
09:45;M1;70.5;13.5;PRUEFEN
10:00;M1;68.9;12.9;OK
10:15;M1;68.4;12.6;OK

Speichere diese Datei lokal als:

technik_analyse/
  data/
    process_v1.csv
  src/
  output/

Lerneinheit 1: Datenstand eindeutig festhalten

Eine Dateibezeichnung wie `neu_final_2.csv` ist keine belastbare Versionsangabe. Besser ist eine nachvollziehbare Kombination aus Dateiname, Prüfsumme, Datum und Beschreibung.

Merksatz: Die Prüfsumme identifiziert den Dateiinhalt. Wird auch nur ein Zeichen geändert, ändert sich normalerweise die Prüfsumme.

# src/hash_daten.py
from pathlib import Path
import hashlib

datei = Path("data/process_v1.csv")
inhalt = datei.read_bytes()
sha256 = hashlib.sha256(inhalt).hexdigest()

print("Datei:", datei)
print("SHA256:", sha256)

Starte lokal im Ordner `technik_analyse`:

python src/hash_daten.py

Warum reproduzierbar? Der Code liest genau eine benannte Datei und berechnet eine standardisierte Prüfsumme. Eine spätere Auswertung kann dadurch auf denselben Inhalt verweisen.

Mini-Aufgabe Basis

Notiere zu `process_v1.csv`:

Dateiname
SHA256-Ausgabe
Zweck der Datei

Hilfe 1: Die Prüfsumme erzeugst Du mit `hash_daten.py`.
Hilfe 2: Beschreibe den Zweck knapp, zum Beispiel „fiktive Messwerte der Kühlstrecke für Übungsanalyse“.
Begründetes Feedback: Nur ein Dateiname reicht nicht, weil eine Datei unter demselben Namen verändert werden kann. Die Prüfsumme bindet Deine Dokumentation an den tatsächlichen Inhalt.

Lerneinheit 2: Code lokal versionieren

Git speichert Änderungen als Commits. Für diesen Kurs genügt ein lokales Repository. Es wird nichts ins Internet übertragen.

git init
git add data/process_v1.csv
git commit -m "Fiktiven Datenstand v1 aufnehmen"

Nach dem Analysecode:

git add src/
git commit -m "Lokale Prozessanalyse ergänzen"
git log --oneline

Prüfpunkt: Für Reproduzierbarkeit notierst Du den Commit, der den verwendeten Code enthält.

Mini-Aufgabe Anwendung

Erkläre in zwei Sätzen den Unterschied zwischen:

Dateiversion bzw. Daten-Prüfsumme
Git-Commit des Codes

Hilfe 1: Frage Dich: „Welcher Inhalt wurde analysiert?“ und „Welche Programmlogik wurde ausgeführt?“
Hilfe 2: Daten und Code können sich unabhängig voneinander ändern.
Begründetes Feedback: Eine Analyse ist nur eindeutig, wenn beide Stände feststehen. Gleicher Code mit anderen Daten oder gleiche Daten mit verändertem Code können andere Ergebnisse liefern.

Lerneinheit 3: Analysecode

Die Python-Standardbibliothek enthält das Modul `csv` zum Lesen tabellarischer CSV-Daten. Das folgende Beispiel benötigt keine Netzverbindung und keine zusätzlichen Pakete.

# src/analyse.py
from pathlib import Path
import csv
import statistics

datei = Path("data/process_v1.csv")

with datei.open(encoding="utf-8", newline="") as f:
    rows = list(csv.DictReader(f, delimiter=";"))

temperaturen = [float(r["temp_c"]) for r in rows]
taktzeiten = [float(r["takt_s"]) for r in rows]
auffaellig = [r for r in rows if float(r["temp_c"]) >= 70.0]

print(f"Datensätze: {len(rows)}")
print(f"Temperatur Mittelwert: {statistics.mean(temperaturen):.2f} °C")
print(f"Temperatur Maximum: {max(temperaturen):.2f} °C")
print(f"Taktzeit Mittelwert: {statistics.mean(taktzeiten):.2f} s")
print(f"Temperaturwerte >= 70 °C: {len(auffaellig)}")

Erwartete Kernergebnisse:

Datensätze: 10
Temperatur Mittelwert: 66.53 °C
Temperatur Maximum: 71.20 °C
Taktzeit Mittelwert: 12.63 s
Temperaturwerte >= 70 °C: 2

Wichtig: Die Grenze von 70 °C ist hier nur eine fiktive Übungsregel. Sie ist kein realer Maschinen- oder Sicherheitsgrenzwert.

Mini-Aufgabe Basis

Ändere lokal nur die Ausgabe so, dass zusätzlich der kleinste Temperaturwert erscheint.

Hilfe 1: Python besitzt die Funktion `min(...)`.
Hilfe 2: Verwende `min(temperaturen)`.
Begründetes Feedback: Du veränderst die Auswertung, nicht die Rohdaten. Das ist wichtig, weil Rohdaten und Analysecode getrennt versioniert werden sollten.

Lerneinheit 4: Daten visualisieren

Du erzeugst eine einfache SVG-Grafik lokal. Das Beispiel verwendet nur Python-Standardfunktionen.

# src/visualisiere.py
from pathlib import Path
import csv

quelle = Path("data/process_v1.csv")
ziel = Path("output/temperatur.svg")
ziel.parent.mkdir(exist_ok=True)

with quelle.open(encoding="utf-8", newline="") as f:
    rows = list(csv.DictReader(f, delimiter=";"))

werte = [float(r["temp_c"]) for r in rows]
zeiten = [r["zeit"] for r in rows]

breite, hoehe = 700, 300
links, oben, plot_b, plot_h = 60, 30, 600, 210
vmin, vmax = 60, 72

def x(i):
    return links + i * plot_b / (len(werte) - 1)

def y(v):
    return oben + (vmax - v) * plot_h / (vmax - vmin)

punkte = " ".join(f"{x(i):.1f},{y(v):.1f}" for i, v in enumerate(werte))

svg = [
    f'<svg xmlns="http://www.w3.org/2000/svg" width="{breite}" height="{hoehe}">',
    '<rect width="100%" height="100%" fill="white"/>',
    f'<line x1="{links}" y1="{oben+plot_h}" x2="{links+plot_b}" y2="{oben+plot_h}" stroke="black"/>',
    f'<line x1="{links}" y1="{oben}" x2="{links}" y2="{oben+plot_h}" stroke="black"/>',
    f'<line x1="{links}" y1="{y(70):.1f}" x2="{links+plot_b}" y2="{y(70):.1f}" stroke="gray" stroke-dasharray="6 4"/>',
    f'<polyline points="{punkte}" fill="none" stroke="black" stroke-width="3"/>',
    '<text x="60" y="20">Fiktive Temperaturreihe Kühlstrecke T-17</text>',
    f'<text x="{links+plot_b-100}" y="{y(70)-5:.1f}">70 °C</text>',
]
for i, zeit in enumerate(zeiten):
    svg.append(f'<text x="{x(i)-14:.1f}" y="{oben+plot_h+20}" font-size="10">{zeit}</text>')
svg.append('</svg>')

ziel.write_text("\n".join(svg), encoding="utf-8")
print("Erzeugt:", ziel)

Starte:

python src/visualisiere.py

Öffne danach lokal `output/temperatur.svg`.

Beobachtung im Ausbildungsfall: Ab 09:15 Uhr steigen Temperatur und Taktzeit gemeinsam an; zwei Temperaturen liegen bei oder über der fiktiven 70-°C-Regel. Daraus folgt noch keine Ursache. Die Daten zeigen nur einen zeitlichen Zusammenhang.

Mini-Aufgabe Anwendung

Formuliere eine vorsichtige Aussage zur Grafik, ohne aus einer Korrelation automatisch eine Ursache abzuleiten.

Hilfe 1: Nutze Wörter wie „tritt gleichzeitig auf“, „zeigt einen Zusammenhang“ oder „müsste geprüft werden“.
Hilfe 2: Vermeide „Die Temperatur verursacht die längere Taktzeit“, solange keine geeignete Untersuchung dies belegt.
Begründetes Feedback: Gute Datenanalyse trennt Beobachtung und Ursache. Das verhindert vorschnelle technische Schlussfolgerungen.

Lerneinheit 5: Analyse-Lauf dokumentieren

Ein Analyse-Lauf sollte mindestens Datenstand, Code-Stand, Laufumgebung und Ergebnisse verbinden.

Erzeuge lokal eine Manifest-Datei:

# src/manifest.py
from pathlib import Path
import hashlib
import json
import platform
import subprocess
from datetime import datetime, timezone

data = Path("data/process_v1.csv")
hashwert = hashlib.sha256(data.read_bytes()).hexdigest()

try:
    commit = subprocess.check_output(
        ["git", "rev-parse", "HEAD"],
        text=True
    ).strip()
except Exception:
    commit = "kein-git-commit-verfuegbar"

manifest = {
    "analyse": "Kuehlstrecke T-17",
    "daten_datei": str(data),
    "daten_sha256": hashwert,
    "git_commit": commit,
    "python": platform.python_version(),
    "zeit_utc": datetime.now(timezone.utc).isoformat(),
    "regel": "temp_c >= 70.0 nur als fiktive Uebungsregel",
    "erwartete_kernergebnisse": {
        "anzahl": 10,
        "temp_mittel_c": 66.53,
        "temp_max_c": 71.20,
        "takt_mittel_s": 12.63,
        "temp_ge_70": 2
    }
}

Path("output").mkdir(exist_ok=True)
Path("output/manifest.json").write_text(
    json.dumps(manifest, indent=2),
    encoding="utf-8"
)
print("Manifest geschrieben.")

Reproduzierbarer Minimalablauf:

python src/hash_daten.py
python src/analyse.py
python src/visualisiere.py
python src/manifest.py

Lerneinheit 6: Lokale, isolierte Testumgebung

Verwende einen eigenen Übungsordner oder eine lokale virtuelle Python-Umgebung. Für diesen Kurs sind keine Netzwerkzugriffe erforderlich.

python -m venv .venv

Aktivierung unter Windows PowerShell:

.venv\Scripts\Activate.ps1

Aktivierung unter Linux/macOS:

source .venv/bin/activate

Grenzen der Übung: Keine Scans, keine fremden IP-Adressen, keine Produktiv-SPS, keine Cloud-Uploads, keine Zugangsdaten und keine realen Kundendaten. Wenn reale Betriebsdaten später verwendet werden sollen, brauchst Du eine ausdrückliche Freigabe und die betrieblichen Datenschutz- und Sicherheitsregeln.

Reproduzierbarkeits-Checkliste

Datenversion: Datei und Prüfsumme dokumentiert
Codeversion: Git-Commit dokumentiert
Umgebung: Python-Version dokumentiert
Parameter: Schwellenwerte und Regeln dokumentiert
Ausgabe: Kennzahlen und Grafik gespeichert
Interpretation: Beobachtung und Ursache getrennt
Datenschutz: Nur freigegebene oder fiktive Daten verwendet

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was identifiziert den konkreten Inhalt einer Datendatei besonders zuverlässig? (Eine kryptografische Prüfsumme) (!Der Ordnername) (!Die Bildschirmauflösung) (!Die Farbe des Diagramms)

Wozu dient ein Git-Commit in diesem Kurs? (Einen bestimmten Code-Stand nachvollziehbar festzuhalten) (!Die Temperatur eines Sensors zu messen) (!Eine SPS automatisch zu starten) (!Kundendaten ins Internet zu übertragen)

Welche Aussage gehört zu einer reproduzierbaren Analyse? (Datenstand und Code-Stand werden gemeinsam dokumentiert) (!Nur die fertige Grafik wird gespeichert) (!Die Rohdaten werden nach der Analyse gelöscht) (!Der Dateiname reicht immer als Versionsnachweis)

Warum wird im Übungsfall eine lokale Testumgebung verwendet? (Damit ohne Zugriff auf fremde oder produktive Systeme geübt werden kann) (!Damit reale Kundendaten automatisch geladen werden) (!Damit Sicherheitsregeln entfallen) (!Damit Zugangsdaten öffentlich werden)

Welche Python-Bibliothek des Beispiels liest die CSV-Datei? (csv) (!socket) (!tkinter) (!email)

Welche Aussage zur 70-Grad-Regel ist richtig? (Sie ist nur eine fiktive Übungsregel) (!Sie ist ein universeller Maschinenstandard) (!Sie gilt für jede Kühlanlage) (!Sie ersetzt eine technische Gefährdungsbeurteilung)

Was sollte ein Analyse-Manifest enthalten? (Daten-Prüfsumme und Code-Stand) (!Nur den Namen des Auszubildenden) (!Nur einen Screenshot) (!Nur den Dateipfad ohne weitere Angaben)

Was ist bei gleichzeitig steigender Temperatur und Taktzeit fachlich angemessen? (Einen Zusammenhang beschreiben und die Ursache gesondert prüfen) (!Sofort eine sichere Ursache behaupten) (!Die Daten verändern bis der Zusammenhang verschwindet) (!Alle Messwerte über 70 löschen)

Was darf in diesem Kurs für die Übung verwendet werden? (Fiktive lokale Messdaten) (!Ungefragt kopierte Kundendaten) (!Passwörter aus dem Produktivsystem) (!Fremde Netze ohne Freigabe)

Was verbessert die Wiederholbarkeit eines Analyse-Laufs? (Eine feste Reihenfolge dokumentierter Skripte) (!Unbenannte manuelle Änderungen) (!Nicht gespeicherte Zwischenschritte) (!Unklare Parameter)

Memory

Daten-Prüfsumme	Identifiziert einen konkreten Dateiinhalt
Git-Commit	Kennzeichnet einen konkreten Code-Stand
Manifest	Verbindet Daten, Code, Umgebung und Ergebnis
CSV	Tabellarisches Austauschformat
Reproduzierbarkeit	Analyse kann mit dokumentierten Mitteln wiederholt werden
Rohdaten	Unveränderte Ausgangsdaten einer Analyse

Drag and Drop

Ordne die richtigen Begriffe zu.	Thema
Daten-Prüfsumme	Datenstand
Git-Commit	Codeversion
Python-Version	Laufumgebung
SVG-Datei	Visualisierung
manifest.json	Analysedokumentation

Kreuzworträtsel

Commit	Welche Git-Einheit hält einen gespeicherten Projektstand fest?
Manifest	Welche Datei kann Datenstand, Code und Umgebung zusammen dokumentieren?
Python	Welche Programmiersprache wird in den lokalen Beispielen verwendet?
Rohdaten	Wie heißen die unveränderten Ausgangsdaten einer Analyse?
Analyse	Wie heißt die systematische Auswertung von Daten?
Version	Welcher Begriff bezeichnet einen eindeutig unterscheidbaren Stand?

LearningApps

Lückentext

Gestufte Übungsaufgaben mit Feedback

Basis

Prüfsumme: Führe `hash_daten.py` aus und dokumentiere die Ausgabe.
Kennzahl: Ergänze in `analyse.py` die minimale Temperatur.
Git: Erzeuge einen lokalen Commit für Deinen Analysecode.

Hilfe Stufe 1: Arbeite jeweils nur an einer Datei.
Hilfe Stufe 2: Prüfe nach jeder Änderung, ob das Skript noch läuft.
Feedback: Kleine, überprüfbare Schritte machen Fehler leichter auffindbar und verbessern die Nachvollziehbarkeit.

Anwendung

Datenqualität: Füge in einer Kopie der CSV-Datei einen fehlenden Temperaturwert ein und entscheide, wie Dein Code damit umgehen soll.
Visualisierung: Markiere im lokal erzeugten SVG die fiktive 70-°C-Grenze deutlicher.
Dokumentation: Ergänze das Manifest um eine kurze Analysefrage.

Hilfe Stufe 1: Verändere niemals die einzige Rohdatenkopie.
Hilfe Stufe 2: Definiere vor der Auswertung, was ein fehlender Wert bedeutet.
Feedback: Datenbereinigung ist selbst ein Analyseschritt und muss dokumentiert werden, weil sie Ergebnisse beeinflussen kann.

Transfer

Reproduzierbarkeit: Lass eine andere Person Deinen Ordner lokal ausführen, ohne mündliche Zusatzinformationen zu geben.
Prozessanalyse: Formuliere zwei alternative Erklärungen für den gleichzeitigen Anstieg von Temperatur und Taktzeit.
Audit-Trail: Lege fest, welche Dateien Du für eine spätere Prüfung archivieren würdest.

Hilfe Stufe 1: Stelle Dir vor, Du bist morgen nicht erreichbar.
Hilfe Stufe 2: Prüfe, ob Daten, Code, Parameter, Umgebung und Ergebnis zusammenpassen.
Feedback: Transfer gelingt, wenn Deine Dokumentation unabhängig von Deiner Erinnerung verständlich und technisch wiederholbar ist.

Offene Aufgaben

Leicht

Dateninventar: Erstelle für den fiktiven Fall eine Tabelle mit Datei, Zweck, Version und Prüfsumme.
Ablaufskizze: Zeichne den Weg von Rohdaten über Code bis zum Ergebnis.
Codekommentar: Ergänze den Analysecode um kurze Kommentare für eine andere auszubildende Person.
Ergebnisnotiz: Schreibe fünf Sätze, die Beobachtung, Kennzahl und Unsicherheit sauber trennen.

Standard

Fehlende Werte: Erzeuge lokal eine zweite fiktive Datendatei mit einem fehlenden Wert und entwickle eine dokumentierte Behandlungsregel.
Versionsvergleich: Ändere die fiktive Schwelle von 70 auf 69 Grad und dokumentiere, warum dadurch eine neue Auswertungsversion entsteht.
Peer-Test: Tausche Deinen Übungsordner lokal mit einer anderen Person und protokolliere, welche Schritte ohne Rückfrage funktionieren.
Visualisierung: Erzeuge zusätzlich eine lokale SVG-Grafik für die Taktzeit und vergleiche beide Verläufe.

Schwer

Reproduktionsprotokoll: Entwickle eine einseitige Vorlage, mit der jeder Analyse-Lauf im Ausbildungsbetrieb dokumentiert werden könnte.
Plausibilitätsprüfung: Entwirf Regeln für Wertebereiche, fehlende Zeitstempel und doppelte Datensätze und begründe jede Regel.
Ursachenhypothese: Entwickle drei technisch plausible Hypothesen für den Verlauf, ohne sie als bewiesen darzustellen, und plane passende Prüfungen.
Qualitätssicherung: Entwickle einen lokalen Test, der automatisch prüft, ob Datensatzanzahl, erwartete Spalten und Wertebereiche stimmen.

Lernkontrolle

Reproduktionsfall: Du erhältst nur eine Grafik und einen Python-Dateinamen. Erkläre, welche Informationen fehlen, um das Ergebnis zuverlässig zu reproduzieren.
Versionskonflikt: Zwei Personen verwenden denselben Code-Commit, aber unterschiedliche CSV-Prüfsummen. Erkläre, warum ihre Ergebnisse voneinander abweichen dürfen.
Prozessinterpretation: Temperatur und Taktzeit steigen gleichzeitig. Entwickle eine Vorgehensweise, mit der Du zwischen Beobachtung und möglicher Ursache unterscheidest.
Datenänderung: Eine Person korrigiert einen Rohdatenwert nachträglich. Beschreibe, wie diese Änderung dokumentiert werden muss, damit ältere Auswertungen weiterhin nachvollziehbar bleiben.
Übergabe: Plane die Übergabe einer Analyse an die nächste Schicht so, dass keine mündliche Zusatzinformation notwendig ist.
Sicherheitstransfer: Begründe, warum ein lokaler Übungsdatensatz für die Ausbildung geeigneter ist als ungefragte Experimente an einer realen Anlage.

Lernnachweis

Für einen Lernnachweis solltest Du zeigen können, dass Du:

einen fiktiven Datensatz versionierst und per Prüfsumme identifizierst,
einen lokalen Code-Stand mit Git dokumentierst,
eine Analyse mit lokalem Python nachvollziehbar ausführst,
eine Grafik reproduzierbar erzeugst,
ein Manifest mit Daten-, Code- und Umgebungsangaben erstellst,
Beobachtung, Korrelation und Ursache sprachlich unterscheidest,
Sicherheits-, Datenschutz- und Freigabegrenzen einhältst,
einer anderen Person eine vollständige lokale Reproduktion ermöglichst.

Quellen und Medienrechte

Fachquellen:

Python-Dokumentation: csv – offizielles Python-Handbuch zum Lesen und Schreiben von CSV-Dateien.
Pro Git: Recording Changes – Dokumentation zu Working Tree, Staging und Commits.
Project Jupyter Documentation – Notebooks verbinden Code, Beschreibung, Daten und Ausgaben.
GO FAIR: FAIR Principles – Grundsätze für auffindbare, zugängliche, interoperable und wiederverwendbare digitale Objekte.
Wikipedia: Datenanalyse – Überblick zu Formen und Grundlagen der Datenanalyse.

Geprüfte Wikimedia-Commons-Medien:

Whole-game-of-data-science.png – CC BY 3.0, Autoren: Hadley Wickham, Mine Çetinkaya-Rundel, Garrett Grolemund.
Data visualization process v1.png – Commons-Dateiseite mit Lizenzangaben.
Git data flow simplified.svg – Autor Cmglee; Lizenzangaben auf Commons.
Git operations.svg – CC BY 3.0.
Typical-workflow.png – frei lizenzierte Commons-Datei.
Workflow of computational notebooks.svg – Commons-Dateiseite mit Lizenzangaben.

YouTube:

Tutorial: Versionsverwaltung mit git Teil 1 – eingebettet von YouTube; keine Neulizenzierung des Videos durch diesen Kurs.
Python Tutorial mit pandas und CSV – eingebettet von YouTube; keine Neulizenzierung des Videos durch diesen Kurs.

Hinweis zu Medienrechten: Wikimedia-Commons-Dateien werden entsprechend der jeweiligen Lizenz auf ihrer Dateibeschreibungsseite genutzt. YouTube-Videos werden lediglich über die Plattform eingebettet; ihre Rechte verbleiben bei den jeweiligen Rechteinhabern.