Datei hochgeladen mit MsUpload

(Eco Worthy) Battery Charger 48V 50A

2026-10-11T14:39:59Z

Chris T. Ludwig: /* Handbuch */

(Eco Worthy) Battery Charger 48V 50A

2026-10-11T10:28:35Z

Chris T. Ludwig: Die Seite wurde neu angelegt: „=Allgemeines= Da ich meine Victron/Pylontech-Kombi als PV-unterstuetzte-Notstrom-Anlage mittlerweile anmeldefrei als Inselanlage betreibe und ich dadurch notgedrungen, das interne Ladegeraet des Multiplus abschalten musste, habe ich mich fuer ein ECO-WORTHY 48V 50A Ladegeraet (EWBC) als Ersatz entschieden. Ob und wie der EWBC von Cerbo bzw. von Venus OS unterstuetzt wird muss ich noch herausfinden. =Handbuch= <pdf width="1000" height="500">EcoWorthy_Ba…“

=Allgemeines=
Da ich meine Victron/Pylontech-Kombi als PV-unterstuetzte-Notstrom-Anlage mittlerweile anmeldefrei als Inselanlage betreibe und ich dadurch notgedrungen, das interne Ladegeraet des Multiplus abschalten musste, habe ich mich fuer ein ECO-WORTHY 48V 50A Ladegeraet (EWBC) als Ersatz entschieden.

Ob und wie der EWBC von Cerbo bzw. von Venus OS unterstuetzt wird muss ich noch herausfinden.

=Handbuch=

<pdf width="1000" height="500">EcoWorthy_BatteryCharger_Manual_korrigiert.pdf</pdf>

Datei:EcoWorthy BatteryCharger Manual korrigiert.pdf

2026-10-11T10:28:01Z

Chris T. Ludwig: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

KI Einführung in maschinelles Lernen mit Python und PyTorch

2026-10-11T08:45:44Z

Chris T. Ludwig: /* Request for Comments */

=Allgemeines=
Ich habe hier für mich Informationen zusammengetragen, die mir das Implementieren von eigenen Neuronalen Netzen erlaubt.

Mein Ausgangspunkt sind Experimente mit meiner RTX3060 12GB. Diese laeuft parallel zu meiner Hauptgrafikkarte als reine "KI-Karte" um kein VRAM zu verschenken.

Ein erster Test mit OpenAI Whisper war schnell installiert und laeuft erstaunlich fluessig.

Jetzt ist es aber an der Zeit eigene Modelle zu programmieren und zu trainieren.
Zu diesem Zweck habe ich mir ein vorlesungsaehnliches Script erzeugen lassen, das ich als Leitfaden nutze.

=Skript=

<pdf width="1000" height="300">File:KI_PyTorch_Semesterskript.pdf</pdf>

==Einrichtung (Kapitel 1)==
===CopyBox===
mkdir -p TorchSkript
cd TorchSkript/
source .venv/bin/activate
python -m pip install --upgrade pip
pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126
python -m pip install jupyterlab matplotlib. NumPy
python -m pip install jupyterlab matplotlib NumPy
python kurs.py --smoke
python kurs.py --model linear --epochs 1 --limit 2000 --out run_probe

===MNIST===

Nach der Installation existiert ein Verzeichnis /data/MNIST/raw.

In diesem Verzeichnis liegen die Trainingsgrafiken mit Ihren Labeln.

Die MNIST-Datenbank (Modified National Institute of Standards and Technology database[1]) ist eine öffentlich verfügbare Datenbank von handgeschriebenen Ziffern. Wobei jede Ziffer als 28 × 28 Pixel großes Graustufen-Bild gespeichert ist[1]. Die MNIST-Datenbank besteht aus 60.000 Beispielen im Trainingsdatensatz und 10.000 Beispielen im Testdatensatz. Der Datensatz dient dem Trainieren von Klassifikatoren, unter anderem Convolutional Neural Networks, im weiteren Sinne dem Maschinellen Lernen bzw. der Künstlichen Intelligenz.

<syntaxhighlight lang="bash" line>
-rw-r--r--. 1 chris users 7840016 6. Okt 20:28 t10k-images-idx3-ubyte
-rw-r--r--. 1 chris users 1648877 6. Okt 20:28 t10k-images-idx3-ubyte.gz
-rw-r--r--. 1 chris users 10008 6. Okt 20:28 t10k-labels-idx1-ubyte
-rw-r--r--. 1 chris users 4542 6. Okt 20:28 t10k-labels-idx1-ubyte.gz
-rw-r--r--. 1 chris users 47040016 6. Okt 20:28 train-images-idx3-ubyte
-rw-r--r--. 1 chris users 9912422 6. Okt 20:28 train-images-idx3-ubyte.gz
-rw-r--r--. 1 chris users 60008 6. Okt 20:28 train-labels-idx1-ubyte
-rw-r--r--. 1 chris users 28881 6. Okt 20:28 train-labels-idx1-ubyte.gz
</syntaxhighlight>

Die .gz sind immer die gezippte Variante.
IDX ist ein einfaches binaeres Format für mehrdimensionale Datenfelder, also Arrays oder Tensoren.
Der Dateiname beschreibt den Inhalt:
Bestandteil Bedeutung
*idx1 Eindimensionales Datenfeld, beispielsweise eine Liste von Ziffernlabels
*idx3 Dreidimensionales Datenfeld, beispielsweise viele zweidimensionale Bilder
*ubyte Vorzeichenlose 8-Bit-Zahl: Werte von 0 bis 255, jeweils ein Byte

Bei MNIST sieht das konkret so aus:
- train-images.idx3-ubyte enthält die Bilddaten mit der Form 60.000 × 28 × 28: Anzahl der Bilder × Höhe × Breite. Jeder Pixel hat einen Grauwert von 0 bis 255.
- train-labels.idx1-ubyte enthält 60.000 Zahlen von 0 bis 9. Jede Zahl sagt, welche Ziffer auf dem zugehörigen Bild steht.
Bild und Label sind über ihre Position zugeordnet: Zum ersten Bild gehört das erste Label, zum zweiten Bild das zweite Label usw.
Am Dateianfang steht außerdem ein kleiner Header, der Datentyp, Anzahl der Dimensionen und deren Größen angibt. Danach folgen die eigentlichen Daten. Deshalb sind die Dateien in einem Texteditor nicht sinnvoll lesbar.

Mit dem IDX_Viewer kann man einen Blick in die Dateien werfen.

[[File:Screenshot_idx_viewer.png|400px]]

<syntaxhighlight lang="python" line>
#!/usr/bin/env python3
"""IDX/MNIST-Viewer. Start: python3 idx_viewer.py [bilder [labels]]
Nur Python-Standardbibliothek und Tkinter nötig. Unterstützt auch .gz.
"""
import gzip
import math
import struct
import sys
from pathlib import Path
import tkinter as tk
from tkinter import ttk, filedialog, messagebox

def read_idx(path):
opener = gzip.open if str(path).lower().endswith('.gz') else open
with opener(path, 'rb') as f:
header = f.read(4)
if len(header) != 4 or header[:2] != b'\0\0' or header[2] != 8:
raise ValueError('Keine IDX-Datei mit unsigned-byte-Daten.')
dimensions = header[3]
if dimensions not in (1, 3):
raise ValueError('Unterstützt werden IDX1-Labels und IDX3-Bilder.')
sizes = f.read(dimensions * 4)
if len(sizes) != dimensions * 4:
raise ValueError('Unvollständiger Header.')
shape = struct.unpack('>' + 'I' * dimensions, sizes)
if not all(shape):
raise ValueError('Die Datei enthält eine leere Dimension.')
data = f.read()
if len(data) != math.prod(shape):
raise ValueError(f'Datenlänge stimmt nicht: {len(data)} statt {math.prod(shape)} Bytes.')
return shape, data

class Viewer:
def __init__(self, root):
self.root = root
self.images = None
self.labels = None
self.index = 0
root.title('IDX / MNIST Viewer')
root.geometry('650x610')
toolbar = ttk.Frame(root, padding=10)
toolbar.pack(fill='x')
ttk.Button(toolbar, text='Bilder öffnen …', command=self.open_images).pack(side='left')
ttk.Button(toolbar, text='Labels öffnen …', command=self.open_labels).pack(side='left', padx=8)
self.info = ttk.Label(root, text='Bitte eine idx3-ubyte-Datei öffnen.', wraplength=620)
self.info.pack(padx=10, pady=5)
self.canvas = tk.Canvas(root, background='#242424', highlightthickness=0)
self.canvas.pack(fill='both', expand=True, padx=10, pady=10)
self.canvas.bind('<Configure>', lambda e: self.render())
nav = ttk.Frame(root, padding=10)
nav.pack(fill='x')
ttk.Button(nav, text='◀ Zurück', command=lambda: self.move(-1)).pack(side='left')
ttk.Button(nav, text='Weiter ▶', command=lambda: self.move(1)).pack(side='left', padx=6)
ttk.Label(nav, text='Bildnummer:').pack(side='left', padx=(12, 3))
self.number = tk.StringVar(value='1')
entry = ttk.Entry(nav, textvariable=self.number, width=9)
entry.pack(side='left')
entry.bind('<Return>', lambda e: self.jump())
ttk.Button(nav, text='Gehe zu', command=self.jump).pack(side='left', padx=6)
self.status = ttk.Label(root, text='Pfeiltasten: blättern · Bildnummern beginnen bei 1')
self.status.pack(pady=(0, 10))
root.bind('<Left>', lambda e: self.move(-1))
root.bind('<Right>', lambda e: self.move(1))

def choose(self, title):
return filedialog.askopenfilename(title=title, filetypes=[('Alle Dateien', '*')])

def open_images(self, path=None):
path = path or self.choose('IDX3-Bilddatei auswählen')
if not path:
return
try:
shape, data = read_idx(path)
if len(shape) != 3:
raise ValueError('Bitte eine IDX3-Bilddatei auswählen.')
self.shape, self.images, self.path = shape, data, path
self.labels = None
self.index = 0
self.render()
# Die übliche MNIST-Labeldatei automatisch finden.
candidate = Path(path).with_name(Path(path).name.replace('images', 'labels').replace('idx3', 'idx1'))
if candidate != Path(path) and candidate.is_file():
self.open_labels(str(candidate))
except (OSError, ValueError, EOFError) as exc:
messagebox.showerror('Datei kann nicht geöffnet werden', str(exc))

def open_labels(self, path=None):
if self.images is None:
messagebox.showinfo('Bilder fehlen', 'Bitte zuerst die Bilddatei öffnen.')
return
path = path or self.choose('IDX1-Labeldatei auswählen')
if not path:
return
try:
shape, data = read_idx(path)
if len(shape) != 1 or shape[0] != self.shape[0]:
raise ValueError('Die Labeldatei muss eindimensional sein und gleich viele Einträge wie die Bilddatei enthalten.')
self.labels = data
self.render()
except (OSError, ValueError, EOFError) as exc:
messagebox.showerror('Labels können nicht geöffnet werden', str(exc))

def move(self, offset):
if self.images is not None:
self.index = min(max(0, self.index + offset), self.shape[0] - 1)
self.render()

def jump(self):
if self.images is None:
return
try:
number = int(self.number.get())
if not 1 <= number <= self.shape[0]:
raise ValueError
self.index = number - 1
self.render()
except ValueError:
messagebox.showerror('Ungültige Bildnummer', f'Bitte eine Zahl von 1 bis {self.shape[0]} eingeben.')

def render(self):
if self.images is None:
return
count, height, width = self.shape
self.number.set(str(self.index + 1))
label = str(self.labels[self.index]) if self.labels is not None else 'nicht geladen'
self.info.config(text=f'{Path(self.path).name}\n{count:,} Bilder · {width} × {height} Pixel · Label: {label}')
start = self.index * width * height
pixels = self.images[start:start + width * height]
# Pixel direkt setzen: funktioniert auch ohne PGM-Unterstützung.
original = tk.PhotoImage(width=width, height=height)
palette = [f'#{v:02x}{v:02x}{v:02x}' for v in range(256)]
rows = ['{' + ' '.join(palette[v] for v in pixels[y * width:(y + 1) * width]) + '}'
for y in range(height)]
original.put(' '.join(rows))
cw, ch = self.canvas.winfo_width(), self.canvas.winfo_height()
scale = max(1, min(max(1, cw - 20) // width, max(1, ch - 20) // height))
self.photo = original.zoom(scale, scale)
self.canvas.delete('all')
self.canvas.create_image(cw // 2, ch // 2, image=self.photo, anchor='center')
self.status.config(text=f'Bild {self.index + 1} / {count} · Vergrößerung {scale}× · ← / → zum Blättern')

def main():
root = tk.Tk()
viewer = Viewer(root)
if len(sys.argv) > 1:
viewer.open_images(sys.argv[1])
if len(sys.argv) > 2:
viewer.open_labels(sys.argv[2])
root.mainloop()

if __name__ == '__main__':
main()
</syntaxhighlight>

===Konzentrat===

====Lernziele:====
*Klassifikationsaufgabe formulieren
*Tensorformen erklären
*einen Datenfluss implementieren
*Gradienten und Training nachvollziehen
*geeignete Metriken berechnen sowie ein Modell speichern und für neue Eingaben benutzen
*außerdem Datenleckage, Überanpassung und irreführende Aussagen über Modellwahrscheinlichkeiten erkennen.

===Baseline:===
Eine Baseline ist ein einfacher Referenzwert oder eine Ausgangslösung, mit der du spätere Ergebnisse vergleichst.

Beim Trainieren eines KI-Modells für die MNIST-Ziffernerkennung könnten Baselines sein:
{| class="wikitable"
! Baseline !! Zweck
|-
| Zufällig eine Ziffer von 0 bis 9 wählen || Im Durchschnitt etwa **10 % Trefferquote**
|-
| Immer die häufigste Ziffer vorhersagen || Zeigt, was ohne Auswertung der Bilder erreichbar ist
|-
| Ein einfaches Modell trainieren || Liefert einen praktischen Vergleich für komplexere Modelle
|}

Beispiel: Dein einfaches Modell erreicht 92 % richtige Zuordnungen. Diese 92 % dienen als Baseline. Ein aufwendigeres Modell erreicht anschließend 97 % — eine Verbesserung um 5 Prozentpunkte.

Die Baseline hilft also bei der Frage: Bringt meine neue Methode tatsächlich einen Vorteil? Dafür müssen beide Modelle mit denselben Testdaten bewertet werden.

====CheckEnviroment====
<syntaxhighlight lang="python" line>
import sys

def check_environment():
print('Python:', sys.version)
print('Python:', sys.version.split()[0])
print('Python-Interpreter:', sys.executable)
print('Virtuelle Umgebung aktiv:', sys.prefix != sys.base_prefix)
print('Umgebungspfad:', sys.prefix)
try:
import torch
except ImportError:
print('PyTorch: nicht installiert oder nicht importierbar.')
return
print('PyTorch:', torch.__version__)
print('CUDA-Version des PyTorch-Builds:', torch.version.cuda)
if torch.cuda.is_available():
device = torch.device('cuda:0')
print('Verfügbare CUDA-Geräte:', torch.cuda.device_count())
for index in range(torch.cuda.device_count()):
print(f' cuda:{index}:', torch.cuda.get_device_name(index))
elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
device = torch.device('mps') # MPS Backend (Metal Performance Shaders) Apple Silicon GPU
else:
device = torch.device('cpu')
print('Gewähltes Gerät:', device)
# Kleine Rechenprobe auf dem ausgewählten Gerät.
result = (torch.tensor([1.0, 2.0], device=device) * 2).cpu().tolist()
print('PyTorch-Rechenprobe:', result)

if __name__ == '__main__':
check_environment()
</syntaxhighlight>

'''Anmerkung:'''

.cpu().tolist() wandelt einen PyTorch-Tensor in eine normale Python-Liste um. Das passiert in zwei Schritten:
{| class="wikitable"
!Aufruf!!Bedeutung
|-
|.cpu()|| Überträgt den Tensor in den Arbeitsspeicher der CPU, falls er auf der GPU liegt. Liegt er bereits auf der CPU, bleibt er dort.
|-
|.tolist()|| Wandelt die Tensorwerte in Python-Zahlen und eine Python-Liste um. Bei mehrdimensionalen Tensoren entstehen verschachtelte Listen.
|}
Das Ergebnis enthält dieselben Zahlen, ist aber kein Tensor mehr.
Übrigens: .tolist() überträgt einen GPU-Tensor automatisch zur CPU. Hier würde deshalb auch allein .tolist() genügen; .cpu() macht den Transfer nur ausdrücklich sichtbar.

====Vokabel====
*'''Zielklasse''':
*'''Trainingsphase''':
*'''Infernezphase''':
*'''Qualitaetsmasz''':
*'''Konfusionsmatrix''': Eine Konfusionsmatrix (Confusion Matrix) zeigt, welche Klassen ein Klassifikationsmodell richtig erkennt und welche es miteinander verwechselt. Hauptdiagonale=richtige Klassifikation alle anderen Angaben sind Fehlklassifiaktionen.
*'''Accuracy''': Die Accuracy (Trefferquote) gibt an, welcher Anteil aller Vorhersagen korrekt war. Bei einer Konfusionsmatrix kannst du die Accuracy ebenfalls direkt bestimmen:
<math>Accuracy=\frac{Summe der Hauptdiagonale}{Summe aller Eintraege}</math>

Merke:
Die Accuracy sagt: „Wie oft lag das Modell richtig?“
Die Konfusionsmatrix sagt zusätzlich: „Was wurde womit verwechselt?“
*'''Mehrheitsklassen-Baseline''':
*'''Taxonomie''': Die Taxonomie ist nicht Bestandteil des neuronalen Netzes an sich. Sie beschreibt die fachliche Struktur der Klassen. Das neuronale Netz ist das Verfahren, mit dem die Zuordnung zu diesen Klassen gelernt werden kann.

Merke:
Taxonomie = Welche Klassen gibt es?
Klassifikation = Zu welcher Klasse gehört eine Eingabe?
Neuronales Netz = Wie kann diese Zuordnung aus Beispielen gelernt werden?

====Ueberblick====

{| class="wikitable"
|-
!Begriff
!Bedeutung
!Beispiel Ziffernerkennung
|-
|Klasse
|Eine mögliche Kategorie
|„7“
|-
|Zielklasse
|Die Klasse, der ein konkretes Beispiel tatsächlich zugeordnet werden soll
|Das Bild zeigt tatsächlich eine 7
|-
|Label
|Technische Repräsentation der Zielklasse in den Daten
|`7`
|-
|Taxonomie
|Festgelegtes System aller Klassen und ggf. ihrer Beziehungen
|`{0,1,2,...,9}`
|-
|Klassifikation
|Die Aufgabe bzw. der Vorgang, eine Eingabe einer Klasse zuzuordnen
|Bild → „7“
|-
|Klassifikator
|Das System/Modell, das die Klassifikation durchführt
|neuronales Netz
|-
|Vorhersage / Prediction
|Die vom Modell bestimmte Klasse
|Modell sagt: „7“
|-
|Konfidenz / Score
|Wie stark das Modell eine Klasse bevorzugt
|„7“: 92 %
|-
|Ground Truth
|Die als korrekt angenommene Zuordnung
|tatsächliches Label = `7`
|-
|Accuracy
|Anteil aller korrekten Klassifikationen
|94 % richtig
|-
|Konfusionsmatrix
|Zeigt, welche Klassen miteinander verwechselt werden
|7 wird oft als 1 erkannt
|}

====Musterloesung====

Ich fand die Aufgabenstellung im Skript suboptimal. Entweder man setzt einen engeren Rahmen der Erwartung, oder zerteilt sie in Teilaufgaben. Die Fragestellung ist didaktisch unklug.

Zur Erinnerung:
<pre>
try:
# Code that may raise an exception
except:
# Runs if an exception occurs
else:
# Runs if no exception occurs
finally:
# Always executed
</pre>

TODO

==Tensoren (Kapitel 2)==

NCHW is an acronym describing the order of the axes in a tensor containing image data samples.

N: Number of data samples.

C: Image channels. A red-green-blue (RGB) image will have 3 channels.

H: Image height.

W: Image width.

===Debuggen===

print(f"{x=}, type={type(x)}") Das kommt dem Zweck von var_dump() wie in PHP schon recht nahe.

Skript Seite 5:
<syntaxhighlight lang="python" line>
import torch # Importiert die Bibliothek PyTorch unter dem Namen "torch".

# ------------------------------------------------------------
# 1. Einen Batch (Charge/Stapel) mit vier zufälligen Bildern erzeugen
# ------------------------------------------------------------

# Erzeugt einen Tensor mit Zufallszahlen zwischen 0 und 1. [0,1) (0 inclusive, 1 exclusive)
# Die Dimensionen bedeuten:
# 4 = Anzahl der Bilder im Batch
# 1 = Anzahl der Kanäle (Graustufenbild)
# 28 = Höhe des Bildes
# 28 = Breite des Bildes
# Der Tensor hat also 4 x 1 x 28 x 28 = 3136 Elemente bzw. Postionen.
# Die einzelnen Elemente (Spalten) und Zeilen werden jeweils durch Komma getrennt.
# Die Tensorausgabe liest man am besten rueckwaerts. Die innerste eckige Klammer ist die Representation des letzten Parameters im tensor-Befehl, usw.
# Tensoren werden hier als eine verschachtelte Liste gefuehrt.
x = torch.rand(4, 1, 28, 28)

# Gibt den kompletten Tensor sowie seinen Python-Typ aus.
print(f"{x=}, type={type(x)}")

# Für Tensoren sind zusätzlich Shape, Datentyp und Gerät interessant.
print(f"{x.shape=}, type={type(x.shape)}") # Form/Dimensionen
print(f"{x.ndim=}, type={type(x.ndim)}") # Anzahl der Dimensionen
print(f"{x.numel()=}, type={type(x.numel())}") # Anzahl aller Elemente
print(f"{x.dtype=}, type={type(x.dtype)}")
print(f"{x.device=}, type={type(x.device)}")

# ------------------------------------------------------------
# 2. Die zugehörigen Zielklassen erzeugen
# ------------------------------------------------------------

# Für die vier Bilder werden vier Zielklassen angegeben.
# Bild 0 gehört zur Klasse 2.
# Bild 1 gehört zur Klasse 7.
# Bild 2 gehört zur Klasse 0.
# Bild 3 gehört zur Klasse 9.
#
# dtype=torch.long erzeugt ganzzahlige 64-Bit-Werte.
# Dieser Datentyp wird z. B. von CrossEntropyLoss für Klassenlabels erwartet.
y = torch.tensor([2, 7, 0, 9], dtype=torch.long)

print(f"{y=}, type={type(y)}")
print(f"{y.shape=}, type={type(y.shape)}")
print(f"{y.dtype=}, type={type(y.dtype)}")
print(f"{y.device=}, type={type(y.device)}")

# ------------------------------------------------------------
# 3. Überprüfen der Tensorformen
# ------------------------------------------------------------

# Prüft, ob x tatsächlich die erwartete Form besitzt.
# Falls die Bedingung falsch ist, wird ein AssertionError ausgelöst.
assert x.shape == (4, 1, 28, 28)

# Wir geben die geprüfte Bedingung zusätzlich aus.
print(f"{x.shape == (4, 1, 28, 28)=}, type={type(x.shape == (4, 1, 28, 28))}")

# Prüft, ob y genau vier Zielklassen enthält.
assert y.shape == (4,)

print(f"{y.shape == (4,)=}, type={type(y.shape == (4,))}")

# ------------------------------------------------------------
# 4. Bilder in Vektoren umwandeln
# ------------------------------------------------------------

# flatten(start_dim=1) lässt Dimension 0 unverändert.
#
# Vorher:
# (4, 1, 28, 28)
#
# Die Dimensionen ab Dimension 1 werden zusammengefasst:
#
# 1 * 28 * 28 = 784
#
# Ergebnis:
# (4, 784) Also 784 Werte in einer Zeile [x11, x12, x13, ....x1784] und das viermal.
#
# Wir haben danach also weiterhin vier Beispiele,
# aber jedes Bild wird als Vektor mit 784 Zahlen dargestellt.
flat = x.flatten(start_dim=1)

print(f"{flat=}, type={type(flat)}")
print(f"{flat.shape=}, type={type(flat.shape)}")

# Prüft die erwartete Form.
assert flat.shape == (4, 784)

print(f"{flat.shape == (4, 784)=}, type={type(flat.shape == (4, 784))}")

# ------------------------------------------------------------
# 5. Ein einzelnes Bild aus dem Batch auswählen
# ------------------------------------------------------------

# x[0] wählt das erste Bild aus.
#
# x hatte die Form:
#
# (4, 1, 28, 28)
# ^
# diese Dimension wird durch [0] entfernt ????
# Was dieser Hinweis von ChatGPT zu bedeuten hat weisz ich nicht.
# Vielmehr wird mit single = x[0] der erste Eintrag des Tensors mit 784 Werten mit dem Shape (1,28,28) der Variablen single zugewiesen.
# besser erkennbar durch:
# first = x[0]
# second = x[1]
# third = x[2]
# fourth = x[3]
#
# Deshalb hat single nur noch:
#
# (1, 28, 28)
single = x[0]

print(f"{single=}, type={type(single)}")
print(f"{single.shape=}, type={type(single.shape)}")

# Kontrolle:
assert single.shape == (1, 28, 28)

print(f"{single.shape == (1, 28, 28)=}")

# ------------------------------------------------------------
# 6. Einen Batch erzeugen, der nur ein Bild enthält
# ------------------------------------------------------------

# x[0:1] ist ein sogenannter Slice.
#
# Im Gegensatz zu x[0] wird die erste Dimension NICHT entfernt.
#
# Aus
#
# (4, 1, 28, 28)
#
# wird deshalb:
#
# (1, 1, 28, 28)
#
# Das bedeutet:
# Wir haben weiterhin einen Batch, aber dieser enthält nur ein Bild.
# Slicing Syntax [Start:Stopp]. Der Start-Index ist dabei inklusive, der Stopp-Index exklusive (wird nicht mehr mitgezählt). Ein fehlender Start/Stopp-Wert bedeutet Anfang, bzw. Ende.

batch_of_one = x[0:1]

print(f"{batch_of_one=}, type={type(batch_of_one)}")
print(f"{batch_of_one.shape=}, type={type(batch_of_one.shape)}")

# Kontrolle:
assert batch_of_one.shape == (1, 1, 28, 28)

print(f"{batch_of_one.shape == (1, 1, 28, 28)=}")

# ------------------------------------------------------------
# 7. Abschließende Zusammenfassung
# ------------------------------------------------------------

print("\n--- Zusammenfassung ---")

print(f"{x.shape=}")
print(f"{y.shape=}")
print(f"{flat.shape=}")
print(f"{single.shape=}")
print(f"{batch_of_one.shape=}")
</syntaxhighlight>

===CrosEntropyLoss===
CrossEntropyLoss ist eine sehr haeufig verwendete '''Verlustfunktion (Loss Function) fuer Klassifikationsprobleme''' in PyTorch.

Sie beantwortet während des Trainings im Wesentlichen die Frage:

<blockquote>'''„Wie stark weicht die Vorhersage des neuronalen Netzes von der richtigen Zielklasse ab?“'''
</blockquote>
Nehmen wir deinen Ziffernklassifikator. Die Taxonomie bzw. Klassenmenge besteht aus:

<syntaxhighlight lang="text">0, 1, 2, 3, 4, 5, 6, 7, 8, 9</syntaxhighlight>
Für ein Bild ist die Zielklasse beispielsweise:

<syntaxhighlight lang="python">y = 7</syntaxhighlight>
Das neuronale Netz liefert aber nicht einfach <code>7</code>, sondern zunächst '''10 Ausgabewerte''', sogenannte '''Logits''':

<syntaxhighlight lang="text">Klasse Logit
0 0.2
1 -0.5
2 0.8
3 0.1
4 -0.3
5 0.4
6 0.2
7 3.8 ←
8 0.5
9 1.1</syntaxhighlight>
Je größer der Logit, desto stärker spricht das Modell für diese Klasse.

==== Was macht CrossEntropyLoss daraus? ====

Vereinfacht passieren zwei Dinge:

<math>
\text{Logits}
\xrightarrow{\text{Softmax}}
\text{Wahrscheinlichkeiten}
\xrightarrow{\text{Vergleich mit Zielklasse}}
\text{Loss}
</math>

CrossEntropyLoss kombiniert diese Berechnungen intern. Deshalb solltest du vor CrossEntropyLoss normalerweise '''kein eigenes softmax()''' aufrufen.

In PyTorch sieht das beispielsweise so aus:

<syntaxhighlight lang="python">import torch
import torch.nn as nn

# Ausgabe des neuronalen Netzes:
# 4 Bilder und jeweils 10 Klassen
logits = torch.rand(4, 10)

# Richtige Zielklassen der vier Bilder
y = torch.tensor([2, 7, 0, 9], dtype=torch.long)

# Verlustfunktion erzeugen
loss_fn = nn.CrossEntropyLoss()

# Verlust berechnen
loss = loss_fn(logits, y)

print(f"{logits.shape=}")
print(f"{y.shape=}")
print(f"{loss=}")</syntaxhighlight>
Dabei ist entscheidend:

<syntaxhighlight lang="text">logits.shape = (4, 10)
│ │
│ └── 10 mögliche Klassen
└────── 4 Bilder

y.shape = (4,)
│
└── eine richtige Zielklasse pro Bild</syntaxhighlight>
Das passt genau zu deinem bisherigen Beispiel:

<syntaxhighlight lang="text">Bild x[0] → Zielklasse 2
Bild x[1] → Zielklasse 7
Bild x[2] → Zielklasse 0
Bild x[3] → Zielklasse 9</syntaxhighlight>


==== Warum braucht man überhaupt einen Loss? ====

Beim Training läuft vereinfacht diese Kette ab:

<syntaxhighlight lang="text">Trainingsbild
↓
Neuronales Netz
↓
Logits
↓
CrossEntropyLoss ← richtige Zielklasse
↓
Loss
↓
Backpropagation
↓
Gewichte des Netzes verändern</syntaxhighlight>
Ein '''kleiner Loss''' bedeutet: Die Vorhersage passt gut zur Zielklasse.

Ein '''großer Loss''' bedeutet: Die Vorhersage passt schlecht zur Zielklasse.

Dabei berücksichtigt Cross Entropy nicht nur, ob die endgültige Klassifikation richtig oder falsch war, sondern auch, '''wie sicher das Modell dabei war'''. Eine selbstbewusste falsche Vorhersage wird stärker bestraft als eine unsichere falsche Vorhersage.

Das ist auch der entscheidende Unterschied zur '''Accuracy''':

<math>
\text{CrossEntropyLoss → zum Trainieren}
</math>

<math>
\text{Accuracy → zum Bewerten}
</math>

Die Accuracy ist nämlich nicht gut geeignet, um mittels Backpropagation die Gewichte eines neuronalen Netzes schrittweise zu verbessern.

==Daten (Kapitel 3)==
Dataset: Ein Paar aus Eingabe und Ziel
DataLoader: bündelt Datasets zu Batches

Aufteilen des Datenbestandes:
*Trainingsbestand (groeszter Anteil) bestimmt Parameter
*Validierungsbestand hilft bei Architektur, Lernrate und Epochenzahl
*Testbestand

===TorchVsion===
Torchvision ist eine offizielle, spezialisierte Erweiterungs-Bibliothek für das Deep-Learning-Framework PyTorch, die speziell für Aufgaben im Bereich des maschinellen Sehens (Computer Vision) entwickelt wurde.

Während PyTorch die grundlegenden mathematischen Funktionen und Tensoren bereitstellt, liefert Torchvision die passenden Werkzeuge, um direkt mit Bildern und Videos zu arbeiten.

====Kurzschreibweisen====
from torch.utils.data import random_split, DataLoader
import torch

Dadurch lassen sich random_split und Dataloader direkt aufrufen.

Die Funktion torch.utils.data.random_split wird in PyTorch verwendet, um einen Datensatz (ein Dataset-Objekt) zufällig in mehrere kleinere, sich nicht überschneidende Teildatensätze aufzuteilen.

torch.utils.data.random_split(dataset, lengths, generator=None)

*dataset: Das ursprüngliche Datensatz-Objekt (z. B. geladen via torchvision.datasets).
*lengths: Eine Liste, die angibt, wie groß die einzelnen Teile sein sollen. Das können entweder absolute Zahlen (Anzahl der Bilder/Zeilen) oder Prozentwerte (als Float zwischen 0 und 1) sein.
*generator: Ein optionaler Zufallsgenerator (torch.Generator()). Extrem wichtig für die Reproduzierbarkeit deines Codes.

Das Modul '''torchvision.datasets''' ist die eingebaute Schatzkiste von PyTorch für Bilddaten. Es enthält eine riesige Auswahl an vorgefertigten, populären Datensätzen für das maschinelle Sehen, die du mit nur einer Zeile Code herunterladen, formatieren und direkt in dein neuronale Netzwerk einspeisen kannst.

<pdf height="300">File:torchvision.datasets.pdf</pdf>

assert x.shape[1:] == (1, 28, 28) , f"Falsche Shape: {x.shape}"

Das Schlüsselwort assert (englisch für „behaupten“ oder „versichern“) wird in Python verwendet, um Bedingungen im Code zu überprüfen. Es dient als internes Sicherheitsnetz während der Entwicklung.

Einfacher empfinde sich das Schluesselwort "teste" fuer assert einzusetzen. Bei wahr geht's weiter und bei falsch wird die optionale (Fehler-)Meldung ausgegeben und der Programmablauf abgebrochen.

Mit dem Aufruf '''python -O mein_skript.py''' ignoriert Python alle assert-Zeilen komplett. Das spart im fertigen Produkt Rechenzeit. Eine if-Abfrage hingegen wird immer ausgefuehrt, falls man auf die Idee kaeme die Kontrolle mit einer if-Abfrage zu realisieren.

==Uebung 3==
===Aufgabe 1===
<syntaxhighlight lang="python" line>
print("--- 1. MNIST laden und 6 Bilder anzeigen ---")
# Transformation: PIL-Bild in Fließkomma-Tensor (0 bis 1) umwandeln
transform = transforms.ToTensor()

# Gesamten Trainingsbestand laden (60.000 Beispiele)
full_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)

# 6 Beispielbilder plotten (optional, bricht das Skript nicht ab)
fig, axes = plt.subplots(1, 6, figsize=(12, 3))
for i in range(6):
image, label = full_dataset[i]
# squeeze() entfernt die Kanalachse (1, 28, 28) -> (28, 28) für imshow
axes[i].imshow(image.squeeze(), cmap='gray', vmin=0, vmax=1)
axes[i].set_title(f"Label: {label}")
axes[i].axis('off')
plt.show(block=False) # block=False, damit das Skript weiterläuft
plt.pause(2) # Zeigt das Bild für 2 Sekunden
plt.close()
</syntaxhighlight>
[[File:Skript_PyTorch_Uebung3_Aufgabe1.png|400px]]
===Aufgabe 2===
<syntaxhighlight lang="python" line>
print("\n--- 2. Reproduzierbaren Daten-Split erstellen ---")
# Trennung in 55.000 Training und 5.000 Validierung mit festem Seed 2026
train_set, valid_set = random_split(
full_dataset,
[55000, 5000],
generator=torch.Generator().manual_seed(2026)
)

# Größen und Überschneidungsfreiheit durch Assertions prüfen
assert len(train_set) == 55000
assert len(valid_set) == 5000
assert set(train_set.indices).isdisjoint(set(valid_set.indices))
print("✓ Größenprüfung erfolgreich.")
print("✓ Die Indizes der Teilmengen sind absolut überschneidungsfrei.")
</syntaxhighlight>

===Aufgabe 3===
<syntaxhighlight lang="python" line>
print("\n--- 3. Klassenhäufigkeiten und Baseline bestimmen ---")
# Alle Labels aus dem Trainingsset extrahieren
train_labels = [full_dataset[i][1] for i in train_set.indices]
counts = Counter(train_labels)
print("Häufigkeiten im Training (Ziffer: Anzahl):", dict(sorted(counts.items())))

# Häufigste Klasse ermitteln
frequentest_class, freq_count = counts.most_common(1)[0]
print(f"Die häufigste Ziffer im Trainingsset ist: '{frequentest_class}' (kommt {freq_count}x vor)")

# Baseline auf dem Validierungsset auswerten
valid_labels = [full_dataset[i][1] for i in valid_set.indices]
correct_predictions = sum(1 for label in valid_labels if label == frequentest_class)
baseline_accuracy = correct_predictions / len(valid_set)
print(f"Triviale Baseline-Accuracy auf der Validierung: {baseline_accuracy * 100:.2f}%")
</syntaxhighlight>

===Aufgabe 4===
<syntaxhighlight lang="python" line>
print("\n--- 4. DataLoader & Shuffle-Vergleich ---")
# DataLoader aufbauen (Training MUSS gemischt werden, Validierung NICHT)
train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=0)
valid_loader = DataLoader(valid_set, batch_size=64, shuffle=False, num_workers=0)

print(f"Anzahl der Trainings-Batches (55000 / 64 ohne drop_last): {len(train_loader)}")
print(f"Anzahl der Validierungs-Batches (5000 / 64 ohne drop_last): {len(valid_loader)}")

# Wertebereich prüfen am ersten Batch
x_batch, y_batch = next(iter(train_loader))
assert x_batch.shape[1:] == (1, 28, 28)
assert y_batch.dtype == torch.long
assert 0 <= x_batch.min() and x_batch.max() <= 1
print("✓ Formen und Wertebereiche im ersten Batch erfolgreich validiert.")
</syntaxhighlight>
=Request for Comments=

<comments />

Datei:Skript PyTorch Uebung3 Aufgabe1.png

2026-10-11T07:06:48Z

Chris T. Ludwig: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

KI Vokabel

2026-10-11T06:34:09Z

Chris T. Ludwig: /* In Convolutional Neural Networks (Dilated Convolutions) */

=Maximal Arbitraer=

In der Informatik und Mathematik hat das Konzept der maximalen Arbitrarität eine fundamentale, oft sehr technische Bedeutung. Hier geht es meist um echte Zufälligkeit oder das bewusste Ignorieren von Mustern.


== 1. Kryptographie & Echte Zufallszahlen ==

* Echter Zufall: Computer können von Natur aus nicht rein zufällig handeln. Sie sind deterministisch.
* Maximale Unvorhersehbarkeit: Für sichere Verschlüsselungen braucht man Schlüssel, die maximal arbiträr (unvorhersehbar) sind.
* Hardware-Zufall: Man nutzt physikalische Prozesse (wie atomaren Zerfall oder thermisches Rauschen), um diese absolute Willkür zu erzeugen.


== 2. Algorithmen & „Arbitrary Choice“ ==

* Reihenfolge ist egal: In der theoretischen Informatik bedeutet eine „arbiträre Auswahl“, dass ein Algorithmus irgendein Element wählt.
* Keine Bevorzugung: Es gibt keine Sortierung oder Priorität. Das Ergebnis des Algorithmus muss korrekt sein, egal welches Element zuerst gewählt wird.


== 3. Beliebige Genauigkeit (Arbitrary Precision) ==

* Keine künstlichen Grenzen: Normalerweise speichert ein Computer Zahlen in festen Größen (z. B. 32-Bit oder 64-Bit).
* Unbegrenzte Kapazität: Bei Arbitrary-Precision-Arithmetik (BigInfs) entscheidet der Programmierer oder der Speicher dynamisch, wie groß eine Zahl sein darf. Die Grenze ist maximal flexibel.


== 4. Software-Testing (Fuzzing) ==

* Chaotische Eingaben: Beim sogenannten Fuzz-Testing wird Software mit maximal arbiträren, oft völlig sinnlosen Daten gefüttert.
* Sicherheitslücken finden: Das Ziel ist es, das Programm durch unvorhersehbare Eingaben zum Absturz zu bringen, um versteckte Bugs zu finden.

Siehe auch Arbitrage. Beide Begriffe stammen vom lateinischen Substantiv arbiter (der Schiedsrichter, Richter oder Vermittler). Daraus bildete sich das lateinische Verb arbitrari (ermessen, entscheiden, glauben) und das Substantiv arbitratus („Gutdünken, freie Wahl, freies Ermessen“).

=Zufallszahlen=

Computer koennen keine echten Zufallszahlen erzeugen.

Ja, diese Aussage ist im Kern richtig, solange man von herkömmlichen Standard-Computern und reiner Software ausgeht. Standard-Computer sind deterministisch. Das bedeutet: Sie folgen strikten, logischen Regeln. Wenn ein Computer denselben Startwert (Seed) und denselben Algorithmus nutzt, wird er immer exakt dieselbe Zahlenfolge berechnen. In der Informatik unterscheidet man daher zwei Arten von Zufall:


== 1. Pseudo-Zufallszahlen (PRNGs) – Kein echter Zufall ==

* Die Methode: Reine Software-Algorithmen berechnen Zahlenreihen.
* Das Problem: Sie wirken für Menschen zufällig, sind es aber mathematisch nicht. Wer die Formel und den Startwert kennt, kann jede zukünftige Zahl perfekt vorhersagen.
* Einsatzbereich: Videospiele (z. B. Beute-Verteilung) oder statistische Simulationen.


== 2. Echte Zufallszahlen (TRNGs) – Der physikalische Trick ==

Moderne Computer können heute über Umwege doch echten Zufall erzeugen. Dafür verlassen sie die reine Software-Ebene und nutzen die chaotische Physik der echten Welt:

* Hardware-Zufallsgeneratoren: Speziell verbaute Chips messen winzige, unvorhersehbare physikalische Prozesse.
* Beispiele: Thermisches Rauschen (Wärme von Elektronen), atmosphärisches Rauschen, radioaktiver Zerfall oder das unregelmäßige Tippverhalten eines Nutzers auf der Tastatur, oder Mausbewegungen.
* Einsatzbereich: Hochsichere Verschlüsselungen (Kryptographie) und Banken-IT.


== Fazit ==

Ein Computer kann durch reines Nachdenken (Software) niemals echten Zufall erzeugen. Er benötigt dafür immer ein Stück unberechenbare Natur (Hardware). Möchtest du wissen, wie du in einer Programmiersprache wie Python oder JavaScript den Unterschied zwischen sicherem und unsicherem Zufall nutzt?

=Regression=
In der Künstlichen Intelligenz (KI) und im '''Maschinellen Lernen''' ist Regression ein Verfahren, um eine kontinuierliche Zahl vorherzusagen. Das Ziel ist es, den mathematischen Zusammenhang zwischen Eingabedaten (z. B. Größe eines Hauses) und einem konkreten numerischen Ausgabewert (z. B. dem Preis) zu finden.


== Der Unterschied: Regression vs. Klassifikation ==

Um Regression zu verstehen, hilft der Vergleich mit der Klassifikation:

* Klassifikation (Kategorien): „Ist diese Einnahme Betrug oder legal?“ oder „Ist auf dem Bild eine Katze oder ein Hund?“ (Ja/Nein oder Klassen).
* Regression (Zahlen): „Wie viel Euro wird dieses Haus kosten?“ oder „Wie hoch wird die Temperatur morgen sein?“ (Konkrete Zahlenwerte).


== Typische Beispiele aus der Praxis ==

* Finanzen: Vorhersage des zukünftigen Preises einer Aktie.
* Immobilien: Schätzung des Marktwerts eines Hauses basierend auf Quadratmetern, Lage und Baujahr.
* Wetter: Berechnung der exakten Regenmenge in Millimetern für die nächste Woche.
* Logistik: Schätzung der genauen Lieferzeit (ETA) für ein Paket.


== Wie funktioniert das einfach erklärt? ==

Stell dir eine Grafik mit vielen Punkten vor. Jeder Punkt ist ein Haus: Die X-Achse zeigt die Quadratmeter, die Y-Achse den Preis. Die einfachste Form der Regression (die lineare Regression) legt nun eine optimale gerade Linie so durch diese Punkte, dass der Abstand zu allen Punkten insgesamt so klein wie möglich ist. Wenn du nun ein neues Haus mit einer unbekannten Größe hast, schaut die KI einfach, wo dieser Wert auf der gezeichneten Linie liegt, und spuckt den passenden Preis aus. Möchtest du ein einfaches Code-Beispiel für eine Regression in Python sehen oder wissen, was der Unterschied zwischen linearer und nicht-linearer Regression ist?

=Over-/Underfitting=
In der Künstlichen Intelligenz beschreiben Overfitting (Überanpassung) und Underfitting (Unteranpassung) die beiden Hauptfehler, die ein KI-Modell beim Lernen machen kann. Das Ziel ist immer die Generalisierung: Die KI soll Muster so lernen, dass sie auch bei völlig neuen, unbekannten Daten richtige Vorhersagen trifft.

-----


== 1. Overfitting (Überanpassung) – Das Auswendiglernen ==

Beim Overfitting lernt die KI die Trainingsdaten zu gut. Sie merkt sich nicht nur die echten Regeln, sondern auch das zufällige Rauschen und Details der Beispiele.

* Das Problem: Das Modell verhält sich wie ein Schüler, der die Übungsaufgaben für die Klassenarbeit exakt auswendig lernt, aber das zugrunde liegende Prinzip nicht versteht.
* Der Effekt: Bei den bekannten Trainingsdaten ist die Genauigkeit perfekt (fast 100 %). Sobald die KI aber neue, unbekannte Daten sieht, versagt sie völlig.
* Ursache: Das KI-Modell ist zu komplex für die kleine Menge an Daten, oder es wurde zu lange trainiert.

* Modell lernt die Analyse der Trainingsdaten auswendig.
* Einmodellierung von Rauschfaktoren
* Neue Daten ohne Rauschen passen nicht ins Modell
* Mangelnde Generalisierbarkeit



== 2. Underfitting (Unteranpassung) – Das Übergeneralisieren ==

Beim Underfitting ist das Modell zu einfach gebaut. Es schafft es nicht einmal, die Struktur der Trainingsdaten richtig zu erfassen.

* Das Problem: Der Schüler ist zu faul oder das Thema ist zu schwer. Er versteht weder die Übungsaufgaben noch die echten Prinzipien.
* Der Effekt: Die Genauigkeit ist sowohl bei den Trainingsdaten als auch bei neuen Daten sehr schlecht.
* Ursache: Das Modell ist zu simpel (z. B. eine gerade Linie für ein kurviges Problem) oder es wurde zu kurz trainiert.
* Das Modell konnte keinen Zusammenhang zwischen den Ein- und Ausgabedaten erkennen.
* Vorhersagen höchst ungenau

-----



== Der visuelle Vergleich (am Beispiel einer Hauspreis-Regression) ==

{|
!width="33%"| Underfitting (Zu einfach)
!width="33%"| Sweet Spot (Perfekt)
!width="33%"| Overfitting (Zu komplex)
|-
| Eine starre, gerade Linie durch eine wellige Punktewolke.
| Eine sanfte Kurve, die den echten Trend der Punkte abbildet.
| Eine wilde Schlangenlinie, die exakt durch jeden einzelnen Punkt zackt.
|-
| KI versteht den Trend nicht.
| KI versteht das Prinzip.
| KI lernt Fehler und Zufälle mit.
|}


== Wie löst man das? ==

* Gegen Overfitting: Mehr Trainingsdaten hinzufügen, das Modell vereinfachen (weniger Parameter) oder das Training früher abbrechen (Early Stopping).
* Gegen Underfitting: Ein komplexeres Modell wählen, dem Modell mehr Merkmale (Features) der Daten zur Verfügung stellen oder länger trainieren.

=Regularisierung=
In der Praxis ist Regularisierung die wichtigste Bremse gegen Overfitting. Sie sorgt dafür, dass ein KI-Modell beim Lernen „bestraft“ wird, wenn es zu komplex, zu flexibel oder zu wild wird. Das Ziel ist es, die Kurve oder die mathematische Formel des Modells bewusst flacher und einfacher zu halten, damit sie sich nicht an jeden einzelnen Datenpunkt klammert. Hier sind die drei bekanntesten Methoden der Regularisierung:


== 1. L2-Regularisierung (Ridge Regression) – Die Gewichtsbremse ==

* Wie es funktioniert: Jedes Mal, wenn die KI ein Merkmal (z. B. die Anzahl der Badezimmer) extrem stark gewichtet, verhängt die Regularisierung eine mathematische Strafe. Sie zwingt das Modell, alle Gewichte möglichst klein und nah an Null zu halten.
* Der Effekt: Keine einzelne Eigenschaft darf das gesamte Modell dominieren. Die Vorhersage-Kurve wird dadurch weicher und stabiler.


== 2. L1-Regularisierung (Lasso) – Die Radikalkur ==

* Wie es funktioniert: Auch hier werden große Gewichte bestraft, aber L1 ist aggressiver als L2. Wenn ein Merkmal für die Vorhersage nicht wirklich wichtig ist, drückt L1 das Gewicht dieses Merkmals exakt auf Null.
* Der Effekt: Unwichtige Eigenschaften werden komplett aussortiert. Das Modell wird schlanker und nutzt am Ende nur noch die Variablen, die wirklich einen Unterschied machen (Feature Selection).


== 3. Dropout – Der Trick für Neuronale Netze ==

* Wie es funktioniert: Beim Training von tiefen Neuronalen Netzen schaltet man in jedem Durchgang zufällig (z. B. zu 50 %) einen Teil der künstlichen Neuronen ab.
* Der Effekt: Die Neuronen dürfen sich nicht mehr aufeinander verlassen. Sie können sich keine „Geheimabsprachen“ merken, um bestimmte Trainingsdaten auswendig zu lernen. Jedes Neuron muss nun eigenständig nützliche Muster erkennen. Das Netzwerk wird dadurch extrem robust.


== Zusammenfassung ==

Regularisierung fügt der KI ein wenig Disziplin hinzu. Sie sagt dem Modell: „Finde eine Lösung, aber mach sie so einfach und elegant wie möglich!“ Möchtest du sehen, wie man eine L1- oder L2-Regularisierung mit wenigen Zeilen Code in einer Python-Bibliothek wie scikit-learn einbaut?

==Beispiel scikit-learn==
Hier ist das Beispiel mit der Bibliothek scikit-learn. Wir vergleichen die Standard-Regression (ohne Bremse) mit L1 (Lasso) und L2 (Ridge).

<pre>
from sklearn.linear_model import LinearRegression, Ridge, Lassofrom sklearn.model_selection import train_test_split

# 1. Daten aufteilen (X = Eigenschaften, y = Zielwert/Preis)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# 2. Ohne Regularisierung (Neigt bei vielen Merkmalen zu Overfitting)model_standard = LinearRegression()
model_standard.fit(X_train, y_train)
# 3. L2-Regularisierung (Ridge) -> Hält alle Gewichte kleinmodel_l2 = Ridge(alpha=1.0) # alpha ist die Stärke der Bestrafung
model_l2.fit(X_train, y_train)
# 4. L1-Regularisierung (Lasso) -> Setzt unwichtige Gewichte auf exakt Nullmodel_l1 = Lasso(alpha=0.1)
model_l1.fit(X_train, y_train)
</pre>


== Was bewirkt der Parameter alpha? ==

* alpha = 0: Keine Regularisierung (entspricht der Standard-Regression).
* alpha sehr hoch: Die Strafe ist extrem streng. Das Modell wird zu stark vereinfacht (Gefahr von Underfitting).


== Welches Modell wählt man wann? ==

* Ridge (L2): Wenn du glaubst, dass fast alle deine Merkmale ein bisschen wichtig für die Vorhersage sind.
* Lasso (L1): Wenn du sehr viele Merkmale hast, aber vermutest, dass nur ein paar wenige davon wirklich relevant sind (der Rest wird auf Null gesetzt).

=Rauschen=

Unter Rauschfaktoren (oft auch einfach als Rauschen oder Noise bezeichnet) versteht man in der Künstlichen Intelligenz unerwünschte, fehlerhafte oder irrelevante Daten, die ein KI-Modell ablenken und seine Genauigkeit verschlechtern. [1] In der KI gilt die Grundregel: „Garbage in, garbage out“ (Müll rein, Müll raus). Rauschfaktoren sind genau dieser „Müll“, der die echten Muster in den Daten überlagert. [1, 2] Man unterscheidet im Wesentlichen vier Arten von Rauschfaktoren:


== 1. Datenrauschen (Data Noise) ==

Das sind Fehler, die direkt in den Datensätzen stecken, mit denen die KI trainiert wird: [1]

* Messfehler: Defekte Sensoren (z. B. bei autonomen Autos), die falsche Werte liefern.
* Menschliche Fehler: Falsch beschriftete Daten (z. B. wenn beim Training ein Bild von einer Katze fälschlicherweise als „Hund“ gelabelt wurde).
* Ausreißer (Outliers): Extrem ungewöhnliche Einzelereignisse in den Daten, die den Gesamttrend verfälschen. [1, 3]


== 2. Signalrauschen (Signal Noise) ==

Hierbei handelt es sich um physikalische Störungen bei der Live-Anwendung der KI: [3]

* Audio-KI: Hintergrundgeräusche (z. B. Baustellenlärm oder Stimmengewirr im Krankenhaus), die es einem Sprachassistenten erschweren, Befehle korrekt zu verstehen. [4]
* Bild-KI: Bildrauschen bei Nachtaufnahmen (Körnigkeit durch schlechte Lichtverhältnisse), wodurch die KI Objekte oder Gesichter nicht mehr richtig erkennt. [5]


== 3. Syntaktisches/Strukturelles Rauschen ==

Dies betrifft vor allem generative KIs (wie ChatGPT): [6]

* Kontextloses Füllen: Wenn ein KI-Modell mit unstrukturierten Texten gefüttert wird, die viele Füllwörter oder irrelevanten Code enthalten, verliert es den Fokus auf den eigentlichen Inhalt. Die KI lernt dann das „Rauschen“ des Schreibstils statt der echten Fakten. [7]

-----


== Der paradoxe Twist: Warum KI manchmal Rauschen braucht ==

Obwohl Rauschfaktoren meistens eliminiert werden sollen (z. B. durch Datenbereinigung oder Filter), setzen Entwickler Rauschen in zwei Fällen gezielt als Werkzeug ein: [8, 9]

# Gegen Overfitting (Regularisierung): Man fügt den Trainingsdaten absichtlich künstliches Rauschen hinzu. Die KI lernt dadurch, ungenaue Realdaten zu erwarten, und wird robuster gegen Fehler im echten Leben. [9, 10, 11]
# Bildgenerierung (Diffusionsmodelle): KIs wie Midjourney oder Stable Diffusion erzeugen Bilder, indem sie mit einem komplett verrauschten Pixel-Chaos starten und dieses Schritt für Schritt gezielt „entrauschen“, bis ein klares Bild entsteht. [12]

Möchtest du wissen, wie man Datenrauschen vor dem KI-Training herausfiltert, oder interessiert dich, wie Bild-KIs Rauschen nutzen, um neue Kunstwerke zu erschaffen? [12]

[1] [https://deepchecks.com/glossary/noise-in-machine-learning/ https://deepchecks.com] [2] [https://www.fau.de/2024/11/news/forschung/kuenstliche-intelligenz/zufaelliges-rauschen-verbessert-leistung-von-ki-systemen/ https://www.fau.de] [3] [https://www.youtube.com/watch?v=PQV5qtS1E1U&t=33 https://www.youtube.com] [4] [https://www.youtube.com/watch?v=uoBknPqpm2w&t=15 https://www.youtube.com] [5] [https://www.youtube.com/watch?v=J52RHqpbzDU https://www.youtube.com] [6] [https://digitalzentrum-berlin.de/ki-modelle-im-faktencheck-chatgpt-und-co-liefern-oft-falschaussagen https://digitalzentrum-berlin.de] [7] [https://mstone.ai/blog/reducing-noise-factors-when-evaluating-genai/ https://mstone.ai] [8] [https://www.dhiria.com/en/blog/noise-in-ai-from-disturbance-to-creative-tool https://www.dhiria.com] [9] [https://www.innovatiana.com/en/post/add-noise-in-ai https://www.innovatiana.com] [10] [https://www.sciencedirect.com/science/article/pii/S2772508126000037 https://www.sciencedirect.com] [11] [https://www.youtube.com/watch?v=tcY0MZQGqWE https://www.youtube.com] [12] [https://www.youtube.com/watch?v=p_FNE5Q-180&t=3 https://www.youtube.com]

=Train-Test-Split=

Der Train-Test-Split (Aufteilung in Trainings- und Testdaten) ist der wichtigste Kontrollschritt beim maschinellen Lernen. Er verhindert, dass man die Leistung einer KI falsch einschätzt, und deckt Overfitting sofort auf.


== Das Prinzip ==

Man nimmt seinen gesamten Datensatz und schneidet ihn in zwei Teile:

# Trainingsdaten (ca. 70–80 %): Mit diesem Teil lernt die KI. Sie sucht nach Mustern und passt ihre internen Gewichte an.
# Testdaten (ca. 20–30 %): Dieser Teil wird weggeschlossen. Erst wenn das Training komplett vorbei ist, muss die KI für diese Daten Vorhersagen treffen. Da sie diese Daten noch nie gesehen hat, simuliert dies den Einsatz im echten Leben.


== Warum ist das zwingend notwendig? ==

Wenn man eine KI auf denselben Daten testet, auf denen sie gelernt hat, betrügt man sich selbst. Ein Modell, das einfach nur alle Daten auswendig gelernt hat (Overfitting), würde eine Genauigkeit von 100 % anzeigen. Erst beim Testen mit den isolierten Testdaten zeigt sich, ob die KI die Prinzipien wirklich verstanden hat. ## Das goldene Gesetz: Data Leakage verhindern Es darf niemals Information aus dem Testset in das Trainingsset fließen (Data Leakage).

* Beispiel: Wenn du Daten vor dem Split skalierst oder den Mittelwert bildest, kennt das Trainingsset bereits Eigenschaften des Testsets. Das verfälscht das Testergebnis komplett.


== Code-Beispiel (scikit-learn) ==

Der Split wird in Python standardmäßig so durchgeführt:

<pre>
from sklearn.model_selection import train_test_split
# test_size=0.2 bedeutet: 80% Training, 20% Test
# random_state fixiert den Zufall, damit der Split reproduzierbar bleibtX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
</pre>

Trainingsdaten gut und Testdaten schlecht => Overfitted
Trainingsdaten schlecht und Testdaten schlecht => ?
Trainingsdaten gut und Testdaten gut => gutes Modell
Trainingsdaten schlecht und Testdaten gut => Fehler

Hier ist die gewünschte Zusammenfassung im Markdown-Format:

{|
!width="25%"| Zustand im Training
!width="25%"| Zustand im Test
!width="25%"| Diagnose
!width="25%"| Maßnahme
|-
| Gut
| Schlecht
| Overfitting (Überanpassung)
| Modell vereinfachen, Daten erhöhen, Regularisierung nutzen.
|-
| Schlecht
| Schlecht
| Underfitting (Unteranpassung)
| Modell komplexer machen, mehr Features hinzufügen.
|-
| Gut
| Gut
| Optimales Modell (Sweet Spot)
| Keine Aktion nötig. Bereit für den Produktiveinsatz.
|-
| Schlecht
| Gut
| Fehler / Artefakt (Unnatürlich)
| Code auf Data Leakage prüfen; Verteilung der Datensätze prüfen.
|}

-----



== Die vier Fälle im Detail ==


== 1. Trainingsdaten gut und Testdaten schlecht => Overfitting ==

Das Modell hat die Trainingsdaten quasi auswendig gelernt, inklusive aller Fehler, Ausreißer und des Rauschens. Es verhält sich wie ein Schüler, der die Übungsaufgaben für eine Klausur exakt auswendig lernt, aber das mathematische Prinzip dahinter nicht begreift. Sobald neue, unbekannte Daten (Testdaten) eingespeist werden, bricht die Leistung ein.


== 2. Trainingsdaten schlecht und Testdaten schlecht => Underfitting ==

Das Modell ist zu simpel gebaut oder wurde nicht lange genug trainiert, um überhaupt ein Muster in den Daten zu erkennen. Wenn man versucht, eine komplexe, geschwungene Datenwolke mit einer starren, geraden Linie vorherzusagen, trifft das Modell weder die bekannten noch die unbekannten Daten gut. Es hat den zugrunde liegenden Trend einfach nicht verstanden.


== 3. Trainingsdaten gut und Testdaten gut => Optimales Modell ==

Das ist das perfekte Ziel-Szenario. Das Modell hat die echten, allgemeingültigen Zusammenhänge aus den Daten extrahiert, ohne sich an Details zu überanpassen. Es liefert sowohl auf bekannten als auch auf völlig neuen Daten stabile und präzise Vorhersagen. Das Modell hat erfolgreich generalisiert und ist bereit für die Praxis.


== 4. Trainingsdaten schlecht und Testdaten gut => Systemfehler ==

Dieses Verhalten ist mathematisch unnatürlich. Eine KI kann auf unbekannten Daten logischerweise nicht besser performen als auf den Daten, mit denen sie trainiert wurde. Tritt dieser Fall auf, liegt fast immer ein technisches Problem vor – wie Data Leakage (Daten aus dem Testset sind unbemerkt ins Training gesickert), ein starkes Daten-Ungleichgewicht (das Testset enthält zufällig nur sehr leichte Beispiele) oder eine viel zu restriktive Regularisierung während des Trainings. Soll ich dir zeigen, wie du diese vier Zustände mit einer Grafik (Learning Curve) direkt beim Trainieren deiner KI sichtbar machen kannst?

Weitere Begriffe: geschichteter Split / Stratified Split)

=Kreuzvalidierung (K-Fold/Cross-Validation)=

Die Kreuzvalidierung (engl. Cross-Validation, meist als K-Fold Cross-Validation durchgeführt) ist die Weiterentwicklung des einfachen Train-Test-Splits. Während ein einfacher Split die Daten nur ein einziges Mal teilt, wiederholt die Kreuzvalidierung diesen Prozess mehrfach. Das Ziel ist es, jeden einzelnen Datenpunkt genau einmal zum Testen zu verwenden. Damit schließt man aus, dass ein Modell nur durch Zufall (Glück oder Pech beim Split) gut abgeschnitten hat.

-----


== Das Prinzip: Wie funktioniert K-Fold? ==

Das Wort „K“ steht für eine Zahl (sehr oft wählt man K = 5 oder K = 10). Diese Zahl bestimmt, in wie viele gleich große Teile (Folds) die Daten zerlegt werden. Bei einer 5-fachen Kreuzvalidierung passiert Folgendes:

# Die Daten werden in 5 Blöcke (Block 1 bis 5) unterteilt.
# Es finden 5 aufeinanderfolgende Durchgänge statt:
#* Durchgang 1: Blöcke 1, 2, 3, 4 sind das Trainingsteam – Block 5 ist das Testteam.
#* Durchgang 2: Blöcke 1, 2, 3, 5 sind das Trainingsteam – Block 4 ist das Testteam.
#* Durchgang 3: Blöcke 1, 2, 4, 5 sind das Trainingsteam – Block 3 ist das Testteam.
#* Durchgang 4: Blöcke 1, 3, 4, 5 sind das Trainingsteam – Block 2 ist das Testteam.
#* Durchgang 5: Blöcke 2, 3, 4, 5 sind das Trainingsteam – Block 1 ist das Testteam.
#Am Ende berechnet man den Mittelwert aller 5 Testergebnisse.

===Warum macht man das? (Die Vorteile)===
Maximale Datennutzung: Besonders bei kleinen Datensätzen wertvoll, da jedes Datenbeispiel mal zum Trainieren und mal zum Testen genutzt wird.
* Verlässliche Metriken: Wenn das Modell in allen 5 Durchgängen eine Genauigkeit von ca. 85 % erzielt, ist es stabil. Schwankt es zwischen 60 % und 95 %, ist das Modell instabil und unzuverlässig.
* Perfekt für Hyperparametertuning: Man nutzt die Kreuzvalidierung, um die besten Einstellungen (wie das optimale alpha bei der L1/L2-Regularisierung) zu finden, ohne die finalen, echten Testdaten anzurühren.
*Schaetzt Fehler besser ab als Train-Test-Split

* Nachteil: dauert laenger



== Code-Beispiel in Python (scikit-learn) ==

In der Praxis musst du diese Schleifen nicht selbst schreiben. scikit-learn übernimmt das mit einer einzigen Zeile:

<pre>
from sklearn.model_selection import cross_val_scorefrom
from sklearn.linear_model import Ridge

model = Ridge(alpha=1.0)

# cv=5 bedeutet 5-fache Kreuzvalidierung
# Es gibt uns direkt 5 Genauigkeits-Scores zurück
scores = cross_val_score(model, X, y, cv=5)

print(“Scores der 5 Durchgänge:”, scores)
print(“Mittlere Genauigkeit:”, scores.mean())
</pre>

Weitere Begriffe: Stratified K-Fold (geschichtete Kreuzvalidierung) Zwingend bei ungleich verteilten Klassen (z.B. seltenen Krankheiten).

=Clustering=
Clustering ist ein zentrales Verfahren des Unüberwachten Lernens (Unsupervised Learning) in der Künstlichen Intelligenz. Im Gegensatz zur Regression oder Klassifikation gibt es hier keine vorgegebenen Labels oder Zielwerte (wie z. B. Preise oder Kategorien). Die KI bekommt lediglich einen Haufen Daten und muss selbstständig Gruppen (Cluster) finden. Das Ziel ist es, Datenpunkte so aufzuteilen, dass Elemente innerhalb einer Gruppe sich maximal ähnlich sind, während die Gruppen untereinander sich maximal unterscheiden.

-----


== Die 3 bekanntesten Clustering-Algorithmen==
1. k-Means (Der Klassiker)

* Wie es funktioniert: Du gibst der KI vor, wie viele Gruppen (k) es geben soll. Der Algorithmus platziert zufällig k Mittelpunkte (Zentren) und ordnet jeden Datenpunkt dem nächstgelegenen Zentrum zu. Danach werden die Zentren neu berechnet. Das wiederholt sich, bis die Gruppen stabil sind.
* Nachteil: Man muss die Anzahl der Gruppen vorab kennen. Zudem funktioniert es nur gut bei kreisförmigen/kugelförmigen Datenwolken.



== 2. DBSCAN (Der Dichte-Spezialist) ==

* Wie es funktioniert: Dieser Algorithmus sucht nach Regionen, in denen Datenpunkte besonders dicht beieinanderliegen.
* Vorteil: Er erkennt Gruppen mit völlig beliebigen, komplexen Formen (z. B. eine Gruppe, die sich halbmondförmig um eine andere legt). Zudem erkennt er Ausreißer (Rauschen) automatisch und sortiert sie aus. Du musst die Anzahl der Cluster nicht im Voraus wissen.


== 3. Hierarchisches Clustering (Der Stammbaum) ==

* Wie es funktioniert: Entweder startet jeder Punkt als eigenes Cluster und die KI verschmilzt die ähnlichsten Punkte Schritt für Schritt (Agglomerativ), oder alle starten in einer Gruppe und werden immer feiner aufgeteilt (Divisiv).
* Ergebnis: Es entsteht ein Baumdiagramm (Dendrogramm), an dem man visuell ablesen kann, welche Daten wie stark miteinander verwandt sind.

-----


== Typische Praxisbeispiele ==

* Kundensegmentierung: Eine Marketing-KI analysiert Kaufverhalten und teilt Kunden in Gruppen ein (z. B. „Schnäppchenjäger“, „Premium-Käufer“, „Gelegenheitskäufer“).
* Bildsegmentierung: Pixel mit ähnlichen Farben und Helligkeiten werden gruppiert, um Objekte auf einem Bild zu isolieren (wichtig für autonomes Fahren).
* Anomalieerkennung: Wenn Kreditkartentransaktionen geclustert werden und eine Transaktion völlig abseits aller Gruppen liegt, schlägt das System wegen Betrugsverdacht Alarm.

Weitere Begriffe: k-Means Wie die KI die optimale Anzahl an Clustern (z. B. mit der Ellbogen-Methode) selbst herausfindet?

=Silhouette Methode=
Die Silhouette-Methode ist neben der Ellbogen-Methode das wichtigste Werkzeug, um die Qualität eines Clusterings zu bewerten und die optimale Anzahl an Gruppen (k) zu bestimmen. Während die Ellbogen-Methode nur misst, wie kompakt die Cluster sind, prüft die Silhouette-Methode zusätzlich, ob die Cluster sauber voneinander getrennt sind.

-----


== Der Silhouette-Koeffizient (Die mathematische Idee) ==

Für jeden einzelnen Datenpunkt berechnet die Methode einen Wert zwischen -1 und +1:

* a (Kompaktheit): Der durchschnittliche Abstand des Punktes zu allen anderen Punkten im eigenen Cluster (sollte möglichst klein sein).
* b (Trennung): Der durchschnittliche Abstand des Punktes zu den Punkten im nächstgelegenen fremden Cluster (sollte möglichst groß sein).

Daraus ergibt sich der Wert für einen Punkt: <math display="block">\text{Silhouette} = \frac{b - a}{\max(a, b)}</math> ## Wie interpretiert man das Ergebnis? Wenn man das Clustering für den gesamten Datensatz bewertet, bildet man den Mittelpunkt aller Einzelwerte:

* Nahe +1: Perfektes Clustering. Die Punkte liegen dicht zusammen und sind weit von anderen Gruppen entfernt.
* Nahe 0: Die Cluster überlappen sich stark. Punkte liegen genau auf den Entscheidungsgrenzen.
* Nahe -1: Fehlplatzierung. Die Punkte wurden vermutlich dem falschen Cluster zugeordnet.

{|
| ## Die optimale Clusteranzahl finden
|-
| Um die beste Anzahl an Clustern (k) zu finden, lässt man den Algorithmus (z. B. k-Means) für verschiedene Werte (z. B. k = 2, 3, 4, 5) laufen.
|-
| Die Regel lautet: Die Zahl k, die den höchsten durchschnittlichen Silhouette-Koeffizienten liefert, ist mathematisch gesehen die beste Wahl für deine Daten.
|}


== Code-Beispiel in Python (scikit-learn) ==

from sklearn.cluster import KMeansfrom sklearn.metrics import silhouette_score # Wir testen verschiedene Cluster-Anzahlen von 2 bis 5for k in: kmeans = KMeans(n_clusters=k, random_state=42).fit(X) labels = kmeans.labels_

<pre># Berechne den durchschnittlichen Score für dieses k
score = silhouette_score(X, labels)
print(f"Für k={k} ist der Silhouette-Score: {score:.3f}")
</pre>
Weitere Begriffe: Silhouette-Plot um unsaubere Cluster optisch sofort zu entlarven.

=Reinforcement Learning=
Reinforcement Learning (Bestärkendes Lernen) ist neben dem überwachten (Supervised) und unüberwachten (Unsupervised) Lernen die dritte große Säule des maschinellen Lernens. Das Prinzip basiert auf Psychologie und Evolution: Eine KI lernt hier nicht durch historische Daten, sondern durch Versuch und Irrtum (Trial and Error) sowie durch ein System aus Belohnung und Bestrafung.


== Die 4 Kernkomponenten des Reinforcement Learnings ==

* Der Agent (Die KI): Das System, das lernen soll (z. B. der Autopilot eines Autos oder eine Spielfigur).
* Die Umgebung (Environment): Die Welt, in der sich der Agent bewegt (z. B. die Straße oder das Schachbrett).
* Die Aktion (Action): Die Züge oder Schritte, die der Agent machen kann (z. B. Bremsen, Beschleunigen, Nach-links-Lenken).
* Die Belohnung (Reward): Das Feedback der Umgebung. Ein positiver Wert für gutes Verhalten (z. B. Ziel erreicht) oder ein negativer Wert für Fehler (z. B. Unfall gebaut).


== Wie der Lernprozess abläuft ==

# Völliges Chaos zu Beginn: Der Agent weiß am Anfang absolut nichts über die Welt. Er wählt seine Aktionen maximal arbiträr (zufällig) aus.
# Das Feedback: Macht er etwas richtig, kriegt er Pluspunkte. Macht er etwas falsch, kriegt er Minuspunkte.
# Die Optimierung: Der Agent versucht über Millionen von Durchgängen, seine Strategie (Policy) mathematisch so anzupassen, dass er die langfristige Summe aller Belohnungen maximiert.


== Berühmte Praxisbeispiele ==

* Gaming-KIs: Googles AlphaGo schlug den Weltmeister im extrem komplexen Brettspiel Go. Andere KIs lernten durch Reinforcement Learning, Videospiele wie Super Mario, StarCraft oder Dota 2 auf Profi-Niveau zu spielen.
* Robotik & Autonomes Fahren: Roboter lernen, wie sie laufen, Greifarme bewegen oder Hindernissen ausweichen, indem sie in virtuellen Simulationen Millionen Mal abstürzen, bis sie die perfekte Balance finden.
* ChatGPT (RLHF): Moderne Sprachmodelle nutzen Reinforcement Learning from Human Feedback. Menschliche Trainer bewerten die Antworten der KI. Die KI lernt dadurch, nützlicher, freundlicher und sicherer zu antworten.
* Multi-Agent Hide and Seek bezieht sich meist auf ein berühmtes KI-Experiment von OpenAI (2019)https://openai.com/index/emergent-tool-use/. Dabei wurden zwei Teams von KI-Agenten (Hiders und Seekers) mittels Reinforcement Learning in eine virtuelle 3D-Welt gesetzt, um Verstecken zu spielen.

Weitere Begriffe: Exploration-Exploitation-Dilemma (der Konflikt zwischen Neuem ausprobieren und Bekanntes nutzen), Q-Learning

==Historischer Kontext==
Das Verstärkende Lernen ist historisch gesehen völlig unabhängig von neuronalen Netzen entstanden. Es bildete ein ganz eigenes historisches Teilgebiet, das seine Wurzeln weit vor dem heutigen KI-Boom hatte. [1, 2] Die Entstehung des Reinforcement Learnings basiert historisch auf der Verschmelzung zweier völlig unterschiedlicher Denkschulen: [1]


=== 1. Die psychologische Wurzel: “Trial-and-Error” (Verhaltensbiologie) ===

Lange bevor es Computer gab, untersuchten Psychologen, wie Tiere und Menschen lernen.

* Edward Thorndikes „Gesetz des Effekts“ (1898): Er stellte fest, dass Reaktionen, die eine angenehme Konsequenz haben, häufiger wiederholt werden. [3]
* B.F. Skinner (Operante Konditionierung): Er trainierte Tauben und Ratten in Boxen rein über Belohnung und Bestrafung. [4]
* Die Brücke zur Informatik: Bereits 1948 schlug Alan Turing ein „Pleasure-Pain-System“ für Maschinen vor. 1952 baute Claude Shannon die mechanische Maus „Theseus“, die rein durch Versuch und Irrtum den Weg aus einem Labyrinth erlernte. [5]



=== 2. Die mathematische Wurzel: “Optimal Control” (Regelungstechnik) ===

Seit den 1950er Jahren suchten Ingenieure und Mathematiker nach Wegen, dynamische Systeme (wie Raketen oder Fabrikanlagen) mathematisch optimal zu steuern. [1, 6]

* Richard Bellman (1957): Er erfand die [https://de.wikipedia.org/wiki/Dynamische_Programmierung Dynamische Programmierung] und die mathematische Grundlage aller heutigen RL-Systeme: das Markov-Entscheidungsproblem (MDP). [4, 7]
* Das Problem damals: Bellmans Gleichungen funktionierten perfekt, wenn man die gesamte Welt exakt mathematisch beschreiben konnte (ein “Modell” der Welt hatte). Für die echte, komplexe Welt war das unbrauchbar. [8, 9]



=== Die historische Verschmelzung (Die Geburtsstunde des RL) ===

In den späten 1970er und 1980er Jahren brachten Forscher wie Richard Sutton und Andrew Barto diese beiden Welten zusammen. Sie fragten sich: Können wir die mathematische Optimierung von Bellman nutzen, während die KI die Spielregeln der Welt rein durch die psychologische Methode von Versuch und Irrtum (Trial-and-Error) erlernt? [3, 4, 6, 8] Daraus entstanden die historischen, klassischen RL-Algorithmen, die ohne jedes neuronale Netz funktionierten:

* Tabellarisches Q-Learning (1989 von Chris Watkins): Die KI speichert ihr Wissen nicht in “Neuronen”, sondern in einer riesigen Excel-Tabelle (einer Q-Tabelle). Für jeden Zustand der Welt wird für jede Aktion ein mathematischer Wert eingetragen, wie gut diese Aktion war. [8, 10]
* Beispiel Tic-Tac-Toe: Ein System namens BOXES (1968 von Michie und Chambers) lernte das Spiel perfekt, indem es Streichholzschachteln für jeden Spielzustand nutzte – völlig ohne neuronale Struktur. [5]



=== Warum nutzt man heute dafür Deep Learning? ===

Klassisches Reinforcement Learning (mit Tabellen) stößt an seine Grenzen, wenn es zu viele Zustände gibt. Beim Schach oder bei Videospielen gibt es mehr mögliche Zustände als Atome im Universum – die Tabelle würde unendlich groß werden. [10] Erst im Jahr 2013 kombinierte die Firma DeepMind das historische Reinforcement Learning mit tiefen neuronalen Netzen (Deep Reinforcement Learning). Das neuronale Netz fungiert seitdem lediglich als “Schätzer”, der die riesige Tabelle ersetzt. [11, 12, 13]

Weiterhin interessant: Wie funktioniert das historische Q-Learning mit einer Tabelle im Detail? Wie kann ein KI-System ganz ohne neuronale Netze kluge Entscheidungen treffen?

[1] [http://incompleteideas.net/book/ebook/node12.html https://incompleteideas.net] [2] [https://cacm.acm.org/federal-funding-of-academic-research/rediscovering-reinforcement-learning/ https://cacm.acm.org] [3] [https://www.youtube.com/watch?v=ul6B2oFPNDM&t=178 https://www.youtube.com] [4] [https://intuitionlabs.ai/articles/reinforcement-learning-explained https://intuitionlabs.ai] [5] [https://www.sciencedirect.com/topics/engineering/reinforcement-learning-technique https://www.sciencedirect.com] [6] [http://www.scholarpedia.org/article/Reinforcement_learning https://www.scholarpedia.org] [7] [https://aws.amazon.com/what-is/reinforcement-learning/ https://aws.amazon.com] [8] [https://medium.com/@aiforhuman/the-roots-of-reinforcement-learning-ad605c4d6d89 https://medium.com] [9] [http://www.umiacs.umd.edu/~hal/courses/2016F_RL/RL1.pdf https://www.umiacs.umd.edu] [10] [https://www.prodot.de/ki-glossar/reinforcement-learning https://www.prodot.de] [11] [https://www.mathworks.com/help/reinforcement-learning/ug/what-is-reinforcement-learning.html https://www.mathworks.com] [12] [https://iabac.org/blog/the-evolution-of-reinforcement-learning-in-machine-learning https://iabac.org] [13] [https://www.youtube.com/watch?v=rkrfWpmG3aM https://www.youtube.com]

=CrossEntropyLoss=
`CrossEntropyLoss` ist eine sehr häufig verwendete **Verlustfunktion (Loss Function) für Klassifikationsprobleme** in PyTorch.

Sie beantwortet während des Trainings im Wesentlichen die Frage:

„Wie stark weicht die Vorhersage des neuronalen Netzes von der richtigen Zielklasse ab?“

Nehmen wir deinen Ziffernklassifikator. Die Taxonomie bzw. Klassenmenge besteht aus:

<pre>
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
</pre>

Für ein Bild ist die Zielklasse beispielsweise:

<syntaxhighlight lang="python" line>
y = 7
</syntaxhighlight>

Das neuronale Netz liefert aber nicht einfach `7`, sondern zunächst **10 Ausgabewerte**, sogenannte **Logits**:

<pre>
Klasse Logit
0 0.2
1 -0.5
2 0.8
3 0.1
4 -0.3
5 0.4
6 0.2
7 3.8 ←
8 0.5
9 1.1
</pre>

Je größer der Logit, desto stärker spricht das Modell für diese Klasse.

==Was macht `CrossEntropyLoss` daraus?==

Vereinfacht passieren zwei Dinge:

<math display="block">\text{Logits}
\xrightarrow{\text{Softmax}}
\text{Wahrscheinlichkeiten}
\xrightarrow{\text{Vergleich mit Zielklasse}}
\text{Loss}</math>

CrossEntropyLoss kombiniert diese Berechnungen intern. Deshalb sollte man vor CrossEntropyLoss normalerweise **kein eigenes `softmax()`** aufrufen.

In PyTorch sieht das beispielsweise so aus:

<syntaxhighlight lang="python" line>
import torch
import torch.nn as nn

# Ausgabe des neuronalen Netzes:
# 4 Bilder und jeweils 10 Klassen
logits = torch.rand(4, 10)

# Richtige Zielklassen der vier Bilder
y = torch.tensor([2, 7, 0, 9], dtype=torch.long)

# Verlustfunktion erzeugen
loss_fn = nn.CrossEntropyLoss()

# Verlust berechnen
loss = loss_fn(logits, y)

print(f"{logits.shape=}")
print(f"{y.shape=}")
print(f"{loss=}")
</syntaxhighlight>

Dabei ist entscheidend:

<pre>
logits.shape = (4, 10)
│ │
│ └── 10 mögliche Klassen
└────── 4 Bilder

y.shape = (4,)
│
└── eine richtige Zielklasse pro Bild
</pre>

Das passt genau zu deinem bisherigen Beispiel:

<pre>
Bild x[0] → Zielklasse 2
Bild x[1] → Zielklasse 7
Bild x[2] → Zielklasse 0
Bild x[3] → Zielklasse 9
<pre>

### Warum braucht man überhaupt einen Loss?

Beim Training läuft vereinfacht diese Kette ab:

<pre>
Trainingsbild
↓
Neuronales Netz
↓
Logits
↓
CrossEntropyLoss ← richtige Zielklasse
↓
Loss
↓
Backpropagation
↓
Gewichte des Netzes verändern
</pre>

Ein **kleiner Loss** bedeutet: Die Vorhersage passt gut zur Zielklasse.

Ein **großer Loss** bedeutet: Die Vorhersage passt schlecht zur Zielklasse.

Dabei berücksichtigt Cross Entropy nicht nur, ob die endgültige Klassifikation richtig oder falsch war, sondern auch, **wie sicher das Modell dabei war**. Eine selbstbewusste falsche Vorhersage wird stärker bestraft als eine unsichere falsche Vorhersage.

Das ist auch der entscheidende Unterschied zur **Accuracy**:

<math display="block">\text{CrossEntropyLoss → zum Trainieren}</math>

<math display="block">\text{Accuracy → zum Bewerten}</math>

Die Accuracy ist nämlich nicht gut geeignet, um mittels Backpropagation die Gewichte eines neuronalen Netzes schrittweise zu verbessern.

=Image Manipulation=
==Dilations==

Dilatation (abgeleitet vom lateinischen dilatare für „ausdehnen“ oder „erweitern“) bedeutet allgemein die Erweiterung, Dehnung oder Vergrößerung eines Gefäßes oder eines physikalischen Körpers.

Der Begriff gehoert zur digitalen Bildverarbeitung als morphologische Dilatation (z. B.YOLO und Computervision). Hier ist es eine Operation, bei der Pixel an die Raender von Objekten in einem Binärbild (Schwarz-Weiß-Bild) "angefuegt" werden. Objekte im Bild werden dadurch vergroeszert oder dicker gemacht, um beispielsweise kleine Loecher in erkannten Formen zu schließen oder Linien zu verbinden.

Im Informatik-Zusammenhang bezieht sich Dilatation (engl. dilation) fast ausschließlich auf zwei wichtige Bereiche der Bildverarbeitung und der Deep-Learning-Netzwerke. Beide Konzepte nutzen das mathematische Prinzip der "Ausdehnung", wenden es aber unterschiedlich an:

===In der Bildverarbeitung (Morphologische Dilatation)===
Hier ist die Dilatation (oft zusammen mit ihrem Gegenstück, der Erosion) eine der fundamentalen Operationen, um die Formen von Objekten in digitalen Bildern zu verändern. [1, 2]

Wie es funktioniert: Ein kleiner Filter (ein sogenanntes Strukturelement oder Kernel, z. B. eine Matrix von 3 × 3 Pixeln) wandert Schritt für Schritt über das Bild.
Bei einem Binärbild (Schwarz-Weiß) gilt die Regel: Wenn der Kernel auch nur einen einzigen weißen Pixel berührt, wird der Pixel in der Mitte ebenfalls weiß gefärbt (logisches ODER).
Bei einem Graustufenbild wird der Pixel in der Mitte durch den maximalen Helligkeitswert in der Umgebung ersetzt. [3, 4, 5, 6, 7]
Der Effekt: Weiße/helle Flächen dehnen sich aus (sie "dilatieren"), während schwarze Löcher schrumpfen. [3, 4]

Praxis-Anwendung:
Lücken schließen: Wenn bei einer Texterkennung (OCR) Buchstaben durch Bildrauschen unterbrochen sind, verbindet die Dilatation die Fragmente wieder.
Objekttrennung vorbereiten: Wenn man Objekte (wie Münzen) zählen will, die sich leicht berühren, nutzt man morphologische Operationen, um sie sauber freizustellen. [4, 8]

In Bibliotheken wie OpenCV nutzt man dafür einfach den Befehl cv2.dilate(). [9]

===In Convolutional Neural Networks (Dilated Convolutions)===
Wenn Sie moderne KI-Modelle zur Bildsegmentierung oder Objekterkennung (wie YOLO-Varianten oder WaveNet für Audio) bauen, stoszen Sie auf Dilated Convolutions (atrous convolutions).

Das Problem bei Standard-KI: Um den globalen Kontext eines großen Bildes zu verstehen, müssen KI-Filter tief im Netzwerk sehr groß werden. Große Filter (7 × 7 oder 9 × 9) verbrauchen jedoch enorm viel Rechenleistung.

Die Dilatation-Loesung: Man nimmt einen kleinen Standard-Filter (z. B. 3 × 3) und zieht ihn kuenstlich auseinander, indem man Luecken (Nullen) zwischen die Filterpunkte einfuegt (der sogenannte Dilation Rate-Faktor).

Der Effekt: Der Filter deckt ploetzlich ein viel groeszeres Sichtfeld (Receptive Field) ab, behaelt aber die exakt gleiche Anzahl an rechenintensiven Parametern bei. Die KI "sieht" das große Ganze, ohne langsamer zu werden.

[1] https://medium.com

[2] https://medium.com

[3] https://homepages.inf.ed.ac.uk

[4] https://www.yahboom.net

[5] https://www.youtube.com

[6] https://docs.opencv.org

[7] https://data-flair.training

[8] https://www.cg.tuwien.ac.at

[9] https://www.projectpro.io

=Kernel Shape=
Im Informatik- und KI-Zusammenhang (insbesondere bei Convolutional Neural Networks (CNNs) und der Bildverarbeitung) beschreibt kernel_shape die Dimensionen (Breite und Hoehe) eines Filters (Kernels).
Der Begriff gibt an, wie grosz das gleitende Fenster ist, das Schritt für Schritt über das Bild wandert, um Merkmale wie Kanten, Formen oder Texturen zu extrahieren.
==Format und Darstellung==
Die kernel_shape wird fast immer als ein Tupel oder eine Liste aus zwei (oder drei) Ganzzahlen angegeben: [Hoehe, Breite].

kernel_shape = [3, 3] bedeutet: Der Filter ist eine quadratische Matrix mit 3 Pixeln Höhe und 3 Pixeln Breite (insgesamt 9 Rechenpunkte). Dies ist der absolute Standard in modernen Netzwerken (wie YOLO oder ResNet).

kernel_shape = [5, 5] bedeutet: Ein größerer Filter mit 25 Rechenpunkten, der auf einmal einen größeren Bildbereich analysiert.

kernel_shape = [1, 1] (Pointwise Convolution): Ein minimaler Filter. Er schaut nur auf einen einzigen Pixel, wird aber genutzt, um die Anzahl der Kanäle (Features) zu verändern, ohne die räumliche Bildgröße zu beeinflussen.

==Warum fast immer ungerade Zahlen?==
Sie werden in der Praxis fast ausschließlich ungerade Zahlen (3x3, 5x5, 7x7) als kernel_shape sehen. Der Grund ist mathematischer Natur: Ungerade Matrizen haben einen exakten Mittelpunkt. Dadurch kann der berechnete Wert präzise auf den Pixel projiziert werden, der sich genau in der Mitte des Filters befindet.

==Bezug==
Bei Dilated Convolutions: Wenn Sie eine kernel_shape von [3, 3] haben und die Dilation Rate auf 2 setzen, dehnt sich der Filter optisch aus. Er deckt dann die Fläche einer kernel_shape von [5, 5] ab, berechnet aber weiterhin nur die Werte von 9 Pixeln.

Bei ONNX-Konvertierungen: Wenn Sie ein YOLO-Modell in ONNX konvertieren und es mit Tools wie Netron.app untersuchen, taucht der Begriff kernel_shape in den Attributen jedes Conv-Blocks auf. Er zeigt Ihnen genau, wie die Geometrie der Schichten im Modell aufgebaut ist.

=Group/Pads/Strides=
In einem Conv-Block (Convolutional Layer) eines neuronalen Netzes (wie man sie beim Inspizieren in ONNX oder Netron sieht) beschreiben pads, strides und group die genauen Regeln, wie sich der Filter (Kernel) über das Bild bewegt, wie die Ränder behandelt werden und wie die Kanäle miteinander verrechnet werden.
Zusammen mit der kernel_shape bestimmen diese drei Parameter exakt die Größe des Ausgangsbildes nach der Faltung.
==1. strides (Schrittweite)==
Der stride (meist als [Y, X] angegeben) definiert, um wie viele Pixel der Filter nach jedem Schritt weitergerückt wird.

strides = [1, 1] (Standard): Der Filter verschiebt sich immer nur um genau einen Pixel nach rechts oder unten. Die Auflösung des Bildes bleibt (vorausgesetzt, das Padding stimmt) fast identisch.

strides = [2, 2]: Der Filter springt immer um zwei Pixel vorwärts. Er überspringt also die Hälfte der Daten.

Der Effekt: Das Ausgangsbild wird dadurch exakt halbiert (z. B. von 640 × 640 auf 320 × 320 Pixel). Moderne Netze wie YOLO nutzen stride = [2, 2] anstelle von Pooling-Layern, um das Bild bewusst zu verkleinern und Rechenleistung zu sparen.
==2. pads (Rand-Auffüllung)==
Da ein Filter (z. B. 3 × 3) eine gewisse Breite hat, stoeszt er an den Bildraendern an seine Grenzen. Wenn man den Filter genau auf den allerersten Pixel oben links setzen will, wuerde die linke Haelfte des Filters im "Nichts" haengen. pads loest das, indem künstliche Pixel (meistens Nullen) um das Bild herumgelegt werden.

Die Angabe erfolgt im Format [Top, Left, Bottom, Right].

pads = [0, 0, 0, 0] (Valid Padding): Es wird kein Rand hinzugefuegt. Der Filter darf sich nur dort bewegen, wo er komplett auf das echte Bild passt. Das Ausgangsbild wird dadurch automatisch ein Stueck kleiner.

pads = [1, 1, 1, 1] (Same Padding): Es wird ein 1 Pixel breiter Rand aus Nullen um das gesamte Bild gelegt. In Kombination mit strides = [1, 1] sorgt dies dafür, dass das Ausgangsbild exakt die gleiche Höhe und Breite behält wie das Eingangsbild.
==3. group (Gruppierung der Kanaele)==
Dieser Parameter steuert die Verbindung zwischen den Eingangs-Kanaelen (z. B. RGB = 3 Kanaele) und den Ausgangs-Kanaelen.

group = 1 (Standard / Dense Convolution): Jeder Filter berechnet Werte über alle Eingangskanaele hinweg. Ein Filter schaut sich also gleichzeitig Rot, Grün und Blau an und mischt diese Informationen komplett.

group = In_Channels (Depthwise Separable Convolution): Wenn die Anzahl der Gruppen exakt der Anzahl der Eingangskanäle entspricht, ist jeder Filter strikt auf seinen eigenen Kanal isoliert. Ein "roter" Filter berechnet nur rote Pixel, ein "grüner" Filter nur grüne.

Der Effekt: Das spart massiv Rechenleistung und Parameter (oft bis zu 90 %). Mobile Netze (wie MobileNet) oder extrem komprimierte YOLO-Varianten für Edge-Geräte und FPGAs nutzen dies intensiv, um die Hardware zu entlasten.

==Ein schnelles Rechenbeispiel aus der Praxis==
Ein YOLO-Modell bekommt ein Bild der Größe 640 × 640 Pixel. Es trifft auf einen Conv-Block mit folgenden Attributen:

kernel_shape = [3, 3]

strides = [2, 2]

pads = [1, 1, 1, 1]

Was passiert? Das Padding fügt ringsherum Nullen an (Bild wird virtuell zu 642 × 642). Der 3 × 3-Filter wandert nun im 2-Pixel-Takt (stride = 2) darüber hinweg. Das Ergebnis am Ausgang dieses Blocks ist ein perfekt verkleinertes Feature-Bild der Größe 320 × 320 Pixel.

=Sigmoid=
In einem CNN (Convolutional Neural Network) ist die Sigmoid-Funktion eine mathematische Funktion, die als Aktivierungsfunktion eingesetzt wird. Ihre Hauptaufgabe ist es, eine beliebige Zahl (das Ergebnis einer vorherigen Berechnung) in einen festen Wertebereich zwischen 0 und 1 abzubilden.

Die mathematische Formel lautet:

<math>\sigma(x)=\frac{1}{1+e^{-x}}</math>

Hier ist die Bedeutung und Funktion im CNN-Kontext aufgeschlüsselt:

==1. Die Hauptaufgabe: Wahrscheinlichkeiten berechnen==
Da die Kurve der Sigmoid-Funktion S-förmig verläuft, eignet sie sich perfekt, um Wahrscheinlichkeiten (Scores) auszudrücken.
Ein Wert nahe 0 bedeutet: „Das Objekt ist mit hoher Sicherheit nicht da.“
Ein Wert nahe 1 bedeutet: „Das Objekt ist mit hoher Sicherheit da.“
==2. Einsatzort in Modellen wie YOLO==
In der Objekterkennung (z. B. YOLO) sitzt die Sigmoid-Funktion fast immer am allerletzten Ausgang (Output Layer) des Netzwerks und erfüllt dort zwei Aufgaben:
===Klassifizierung (Multi-Label-Klassifikation)===
Wenn ein Modell erkennen soll, ob auf einem Bild ein „Mensch“, ein „Auto“ oder ein „Hund“ zu sehen ist, schaltet man für jede Klasse eine Sigmoid-Funktion am Ausgang. Das erlaubt es dem Netzwerk zu sagen: „Ich bin mir zu 95 % sicher, dass hier ein Mensch ist, und zu 80 % sicher, dass hier ein Auto ist“ (z. B. wenn ein Mensch im Auto sitzt).
===Begrenzungsrahmen (Bounding Box Regression)===
Um zu verhindern, dass die vorhergesagten Koordinaten einer Box aus dem Bild "springen", jagt man die Koordinaten-Werte durch ein Sigmoid. Dadurch liegen die Werte exakt zwischen 0 und 1 (relativ zur Rasterzelle) und die Box bleibt sauber im Bildbereich.
===Warum nutzt man sie nicht überall im Netzwerk? (Das Problem)===
In den inneren Schichten (Hidden Layers) eines CNNs nutzt man heute fast nie Sigmoid, sondern meistens ReLU (Rectified Linear Unit) oder Varianten wie SiLU (Swish).
Der Grund ist das berüchtigte Vanishing Gradient Problem (Verschwindender Gradient):

Wenn die Werte sehr groß oder sehr klein werden, flacht die Sigmoid-Kurve extrem ab. Die Steigerung (Ableitung) der Kurve geht dann gegen Null. Beim Training des Netzwerks führt das dazu, dass die Fehlerkorrekturen (Gradienten) auf dem Rückweg durch das Netzwerk immer kleiner werden und die vorderen Schichten des Netzes aufhören zu lernen.
===Zusammenfassung: Sigmoid vs. Softmax===
'''Sigmoid:''' Berechnet die Wahrscheinlichkeit für jede Klasse unabhängig voneinander (Werte müssen sich nicht zu 100 % ergänzen). Ideal für Multi-Label-Probleme.

'''Softmax:''' Berechnet die Wahrscheinlichkeiten so, dass sich alle Ausgänge zusammen exakt zu 100 % (1.0) aufaddieren. Ideal, wenn sich Klassen gegenseitig ausschließen (z. B. Entweder Hund oder Katze).

[[File:Sigmoid-Fkt_mit_Ableitung.png|1000px]]

Datei:Sigmoid-Fkt mit Ableitung.png

2026-10-11T06:33:38Z

Chris T. Ludwig: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

2026-10-10T11:33:17Z

Chris T. Ludwig: /* Allgemeines */

KI Modelldateiformate

2026-10-10T11:11:54Z

Chris T. Ludwig: Die Seite wurde neu angelegt: „=Allgemeines= Da es recht viele Dateiformate, in denen Modelldaten gespeichert sind, gibt ist für mich wichtig wie und welche Daten in Datei abgelegt werden. Eins vorab. Es sind wohl alle Formate ineinander konvertierbar. Sie lassen sich auch mit Hilfe der WebApp netron [https://netron.app/] visualisieren. =Die Formate im Überblick= Diese Dateiendungen stehen für gängige Machine-Learning- und Deep-Learning-Modellformate: [1, 2] ==.pt / .pth (PyTor…“

=Allgemeines=
Da es recht viele Dateiformate, in denen Modelldaten gespeichert sind, gibt ist für mich wichtig wie und welche Daten in Datei abgelegt werden.

Eins vorab. Es sind wohl alle Formate ineinander konvertierbar.

Sie lassen sich auch mit Hilfe der WebApp netron [https://netron.app/] visualisieren.

=Die Formate im Überblick=
Diese Dateiendungen stehen für gängige Machine-Learning- und Deep-Learning-Modellformate: [1, 2]

==.pt / .pth (PyTorch)==
Das Standard-Speicherformat von PyTorch (basierend auf Python Pickle). Es speichert Gewichte (state_dict) oder ganze Modelle samt Trainings-Metadaten. Es ist ideal zum Weiter-Trainieren, aber unsicher beim Laden fremder Dateien (Code-Ausführung möglich). [1, 2, 3]
==.safetensors (Hugging Face)==
Ein von Hugging Face entwickeltes, sicheres Format. Es speichert nur reine Tensordaten neben einem JSON-Header, lädt extrem schnell (Lazy-Loading) und verhindert Sicherheitsrisiken durch schädlichen Python-Code. [1]
==.onnx (Open Neural Network Exchange)==
Ein herstellerunabhängiges Standardformat für Rechengraphen. Es dient der Interoperabilität, damit ein Modell aus PyTorch auf anderen Runtimes oder Plattformen (z. B. .NET, Mobile, Web) ausgeführt werden kann. [1, 4]
==.model (Verschiedene)==
Ein generischer Name für Modelldateien (häufig genutzt von Frameworks wie TensorFlow, Scikit-Learn, Keras oder SentencePiece).
==.engine / .trt (TensorRT)==
Ein hochgradig für NVIDIA-GPUs optimiertes Binärformat. Es wird auf einer spezifischen Hardware-Architektur kompiliert und ist nicht portabel auf andere GPU-Typen, bietet dafür aber maximale Inferenz-Geschwindigkeit. [2, 5]

=Typischer Workflow (Pipeline)=
'''Training / Speicherung:''' Das Modell wird in PyTorch als .pt oder .pth trainiert (oder als .safetensors gesichert).
'''Export:''' Das Modell wird nach ONNX (.onnx) exportiert, um eine neutrale Zwischenform des Graphen zu erhalten.
'''Optimierung / Inferenz:''' Über NVIDIA TensorRT (trtexec) wird aus dem ONNX-Modell eine hardware-spezifische .engine- oder .trt-Datei für den schnellen Produktionseinsatz auf GPUs generiert. [2, 4, 5, 6]

Mehr Details zu den Unterschieden findet man im offiziellen Blogbeitrag zu Common AI Model Formats. [1]

[1] https://huggingface.co
[2] https://github.com
[3] https://techjacksolutions.com
[4] https://www.youtube.com
[5] https://huggingface.co
[6] https://github.com

=Die Formate im Detail=
==.pt / .pth (PyTorch)==
Das .pt und .pth Format sind technisch gesehen völlig identisch. Es gibt absolut keinen Unterschied im inneren Aufbau der Dateien. Beide Erweiterungen werden in PyTorch verwendet, um '''serialisierte Modelle, Gewichte oder Tensoren''' zu speichern.
Die unterschiedlichen Dateiendungen sind lediglich eine Namenskonvention:
*.pt: Steht schlicht für PyTorch. Es ist heute der empfohlene Standard, da es Verwechslungen vermeidet.
*.pth: War in älteren PyTorch-Versionen üblich. Der Wechsel zu .pt wurde vollzogen, weil .pth im Python-Ökosystem bereits für Path Configuration Files (Dateien, die dem Python-Suchpfad Verzeichnisse hinzufügen) reserviert ist.
===Aufbau===
Hinter einer .pt oder .pth Datei verbirgt sich seit PyTorch 1.3 (2019) standardmäßig ein unverschlüsseltes ZIP-Archiv. Wenn du die Dateiendung in .zip änderst, kannst du sie mit jedem gängigen Entpacker (wie 7-Zip oder WinRAR) öffnen.
Ein entpacktes PyTorch-Modell (im modernen TorchScript- oder Zip-basierten Format) sieht strukturell meistens so aus:
<pre>
mein_modell.pt (ZIP-Archiv)
│
├── data.pkl # Die serialisierten Python-Metadaten (Pickle-Datei)
├── byteorder # Datei, die die Endianness (z. B. 'little') definiert
├── code/ # (Optional bei TorchScript) Enthält den Python/C++ Code der Modellstruktur
│ ├── __torch__.py
│ └── ...
└── data/ # Ordner mit den eigentlichen Binärdaten
├── 0 # Rohdaten-Tensor 1 (z. B. Weights von Layer 1)
├── 1 # Rohdaten-Tensor 2 (z. B. Biases von Layer 1)
└── ...
</pre>

====data.pkl====
data.pkl (Der Pickle-Teil)
PyTorch nutzt Pythons Pickle-Modul zur Serialisierung. Diese Datei enthält ein Wörterbuch (Python Dictionary), das die Struktur des Modells beschreibt. Es mappt die Namen der Layer (z. B. layer1.weight, layer1.bias) auf die entsprechenden Binärdaten im data/-Ordner.
====data Ordner====
Hier liegen die tatsächlichen numerischen Werte (die gelernten Gewichte und Biases) als reine, unformatierte Binärdaten (Raw Bytes). PyTorch trennt die Metadaten (Struktur) strikt von den schweren Binärdaten (Gewichten), um das Laden extrem schnell zu machen. Mittels Memory Mapping (mmap) können die Gewichte beim Laden direkt aus der Datei in den RAM oder GPU-VRAM gespiegelt werden, ohne dass Python jede Zahl einzeln parsen muss.

===Beschreibung===
Je nachdem, wie das Modell in PyTorch gespeichert wurde, unterscheidet sich der logische Inhalt der data.pkl:

====Nur die Gewichte (state_dict)====
Code: torch.save(model.state_dict(), 'model.pt')
Inhalt: Das Archiv enthält nur die reinen Zahlenwerte der Layer. Die eigentliche Python-Klasse (die Architektur des neuronalen Netzes) ist nicht in der Datei. Zum Laden musst du das Modell erst im Code definieren und dann die Gewichte hineinladen (model.load_state_dict(...)).

====Das gesamte Modell====
Code: torch.save(model, 'model.pt')
Inhalt: Pickle speichert hierbei den Pfad zur Python-Klasse und die Gewichte. Achtung: Wenn du die Datei auf einem anderen Computer lädst, auf dem das exakte Python-Skript mit der Modelldefinition fehlt, stürzt der Ladevorgang ab.

====TorchScript-Modelle====
Code: torch.jit.save(traced_model, 'model.pt')
Inhalt: Enthält zusätzlich den serialisierten Code (im Ordner code/). Solche Dateien können komplett ohne Python (z. B. in einer C++ Laufzeitumgebung) geladen und ausgeführt werden.

Beispiel TODO

==.safetensors (Hugging Face)==
Das .safetensors Format wurde von Hugging Face entwickelt, um die gravierenden Sicherheits- und Performance-Nachteile des klassischen .pt (Pickle)-Formats zu lösen.
Im Gegensatz zu .pt ist eine .safetensors-Datei kein ZIP-Archiv, sondern eine einzelne, kontinuierliche Binärdatei. Ihr Aufbau ist extrem minimalistisch, sicher und auf maximale Ladegeschwindigkeit optimiert.

===Aufbau===
Eine .safetensors-Datei besteht aus exakt drei Abschnitten:
<pre>
┌───────────────────────────┬────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────┐
│ 1. Header-Größe (8 Bytes) │ 2. JSON-Header (Variabler Text-Bereich) │ 3. Tensor-Rohdaten (Reiner Binärblock) │
├───────────────────────────┼────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────┤
│ Gibt an, wie viele Bytes │ Enthält Metadaten und die "Gebrauchsanweisung": │ Hier liegen alle Gewichte und Biases hintereinander │
│ der JSON-Header lang ist. │ Welcher Tensor liegt an welcher Byte-Position (Offset)?│ als unformatierte Bytes (z. B. FP16 oder BF16). │
└───────────────────────────┴────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
</pre>

===Beschreibung===
====Die ersten 8 Bytes (Header Length)====
Die Datei beginnt immer mit einer 64-Bit-Ganzzahl (Unsigned Long in Little-Endian). Diese Zahl sagt dem Parser exakt, wie viele Bytes er ab jetzt lesen muss, um den gesamten Header zu erfassen.

====Der JSON-Header (Metadaten & Wegweiser)====
Direkt nach den ersten 8 Bytes folgt ein ganz normaler UTF-8-kodierter JSON-String.

Dieser Header enthält:
*'''Globale Metadaten''' (Optional): Im Feld __metadata__ können Infos wie das Erstellungsdatum, das Framework oder Einsatzzwecke stehen.
*'''Die Tensor-Map''': Für jeden einzelnen Tensor im Modell gibt es einen Eintrag, der beschreibt, wie er heißt, welche Form er hat, welcher Datentyp genutzt wird und wo genau im darauffolgenden Binärblock er liegt.

====Der Binärblock (Tensor-Rohdaten)====
Direkt nach dem JSON-Header (auf das Byte genau ausgerichtet) folgen die reinen, unkomprimierten numerischen Daten der Tensoren. Es gibt keine Trennzeichen, keine Ordnerstrukturen und keine Kompression. Die Daten liegen genau so im Speicher, wie die Grafikkarte oder CPU sie erwartet.

Da die Daten im Safetensors-Format unkomprimiert und perfekt linear angeordnet sind, kann ein System beim Laden die Datei öffnen und die Adressen im RAM direkt an die GPU übergeben. Die Daten müssen nicht ein einziges Mal im Arbeitsspeicher hin- und herkopiert werden (Zero-Copy).

===Code-Beispiel===
Beispiel für einen solchen JSON-Header:
<syntaxhighlight lang="python" line>
{
"__metadata__": {
"format": "pt"
},
"model.layers.0.self_attn.q_proj.weight": {
"dtype": "F16",
"shape":,
"data_offsets": [0, 33554432]
},
"model.layers.0.self_attn.k_proj.weight": {
"dtype": "F16",
"shape":,
"data_offsets": [33554432, 67108864]
}
}
</syntaxhighlight>

Hinweis zu den data_offsets: Die Zahlen [0, 33554432] bedeuten: Dieser spezifische Tensor beginnt bei Byte 0 des Binärblocks und endet bei Byte 33.554.432.

==.onnx==
Das ONNX-Format (Open Neural Network Exchange) ist grundlegend anders aufgebaut als .pt oder .safetensors. Während die anderen Formate primär flache Wörterbücher (Dictionaries) von Tensoren speichern, speichert ONNX einen vollständigen, serialisierten Berechnungsgraphen (Computation Graph).
Technisch basiert eine .onnx-Datei auf Protocol Buffers (Protobuf), einem von Google entwickelten Verfahren zur Serialisierung strukturierter Daten.

===Aufbau===
Die Struktur einer ONNX-Datei ist streng hierarchisch ineinander verschachtelt und folgt der in Protobuf definierten Architektur. Wenn man die Datei logisch zerlegt, sieht sie so aus:
<pre>
ModelProto (Das Gesamtmodell)
│
├── Metadaten (Version, Ersteller, IR-Version, Opsets)
│
└── GraphProto (Der Berechnungsgraph)
│
├── Input (Eingangs-Knoten, z. B. Bildgröße)
├── Output (Ausgangs-Knoten, z. B. Wahrscheinlichkeiten)
│
├── NodeProto (Die Operationen / Layer)
│ ├── Node 1: Conv (Faltung) ───► Verweist auf Inputs, Outputs & Attribute
│ ├── Node 2: ReLU (Aktivierung)
│ └── ...
│
└── TensorProto (Initializers / Die gelernten Gewichte)
├── Gewichte für Conv 1 (Binärdaten)
└── ...

</pre>
===Beschreibung===
====ModelProto (Der globale Container)====
Das ist die oberste Ebene der Datei. Sie enthält globale Metadaten, die für die Kompatibilität entscheidend sind:
ir_version: Die Version der ONNX-Spezifikation.
opset_import: Extrem wichtig. Es definiert, welche Version der Operatoren-Bibliothek genutzt wird (z. B. "nutze den AI-Opset Version 15"). Das stellt sicher, dass eine Runtime (wie ONNX Runtime) exakt weiß, wie sie eine Operation (wie z. B. Resize oder LSTM) mathematisch ausführen muss.
====GraphProto (Das Netzwerk-Layout)====
Der Graph beschreibt den gesamten Datenfluss. Er verbindet die Eingänge mit den Ausgängen über ein Netz aus mathematischen Operationen. Ein Graph hat keine Schleifen (er ist ein Directed Acyclic Graph oder DAG).
====NodeProto (Die mathematischen Bausteine)====
Jeder "Node" (Knoten) im Graphen entspricht einer mathematischen Operation (z. B. Matrixmultiplikation, Convolutions, Softmax). Ein Node speichert:
op_type: Der Name der Operation (z. B. Conv, Add, MatMul).
input / output: Strings, die die Kanten des Graphen beschreiben. Wenn Node 1 den Output "tensor_1" erzeugt und Node 2 den Input "tensor_1" erwartet, weiß die Runtime, dass diese beiden Layer hintereinandergeschaltet sind.
attribute: Spezifische Einstellungen für diesen Layer (z. B. die Kernel-Größe oder das Stride-Verhalten bei einer Convolution).
====TensorProto (Die "Initializer")====
Hier liegen die gelernten Gewichte und Biases des Modells.
Bei kleineren Modellen liegen diese Parameter direkt eingebettet im jeweiligen TensorProto-Feld als Binärdaten innerhalb der Protobuf-Struktur.

Besonderheit bei großen Modellen (LLMs): Da Protobuf ein striktes Größenlimit von 2 GB pro Datei hat, unterstützt ONNX das Speichern von externen Daten. Die .onnx-Datei enthält dann nur noch die Struktur des Graphen, während die schweren Gewicht-Tensoren in separaten Binärdateien (z. B. model.onnx.data) im selben Verzeichnis abgelegt werden.

Da ONNX den Code in standardisierte mathematische Knoten übersetzt, kann ein in PyTorch trainiertes Modell als ONNX-Datei exportiert und anschließend ohne Python-Laufzeitumgebung direkt auf einer optimierten Engine wie TensorRT (NVIDIA) oder OpenVINO (Intel) mit maximaler Hardware-Ausnutzung ausgeführt werden.

2026-10-10T05:36:34Z

Chris T. Ludwig: Die Seite wurde neu angelegt: „=Allgemeines= Die Idee rechenintensive Operationen in einen dafuer spezialisierten eigenen Prozessor auszulagern ist nicht Neues. Der Intel 80387 ist ein 1987 eingeführter mathematischer Coprozessor (Floating-Point Unit, FPU), der speziell zur Entlastung des Mikroprozessors Intel 80386 bei Gleitkomma- und Trigonometrieberechnungen entwickelt wurde. In diesem Zusammenhang fallen mir immer wieder FPGAs ein. Mit dem Wunsch die KI-spezifischen Operation…“

Hauptseite

2026-10-09T17:27:51Z

Chris T. Ludwig: /* Tipp des Tages */

[[Datei:SchimpansenProgrammierer.png|mini|5-jaehriger Schimpanse(KI generierter Inhalt)|link=5-jaehriger Schimpanse]]

==Allgemeines==
Dieses Wiki erhaelt permanent Erweiterungen. Derzeit beinhaltet dieses Wiki knapp 300 Artikel. Ich nutze dieses Wiki als persoenliche Informationsquelle zu fast allen Dingen mit denen ich mich so beschaeftige, um sie einfach oeffentlich und schnell zur Hand zu haben. Viele Seiten befinden sich noch im Intranet-Wiki und lassen sich aufgrund von Urheberrechtsbestimmungen nicht ohne Ueberarbeitung in dieses oeffentliche Wiki uebertragen. Wenn also Fragen auftauchen, dann schreibt das bitte in die Kommentare. Ich pruefe dann gezielt, ob ich hierzu einen Beitrag freischalten kann.

Meine Site ist '''bannerfree''' und '''genderfree'''. Es gibt keine Affiliate-Links und maximal, wenn man eine Empfehlung so deuten will, mal Schleichwerbung. An einem Verzicht auf Umlaute und scharfes S (SZ) arbeite ich.

===Hinweis zu Suchanfragen===

Sinnvoll ist es bei der Wikisuche mindestens '''4''' Buchstaben mit voran- und nachgestelltem * (Wildcard) nutzen.
Zum Beispiel "*Ardu*", "*FHEM*", "*ENC2*".
Woerter mit 3 Buchstaben findet man auch. Grosz- und Kleinschreibung wird nicht unterschieden. In den runden Klammern vor dem eigentlichen WikiBeitrag steht ein Gruppenname, so sind zusammengehoerende Beitraege besser erkennbar.

Bei der Suche z. B. nach '''KI''' funktionieren auch 2 Buchstaben. Bei KI habe ich den Gruppennamen nicht konsequent in runde Klammern gesetzt.

[[Spezial:Alle_Seiten|Alle Seiten im Ueberblick]]

Nach über 30 Jahre werde ich mich wohl von SuSE verabschieden. Gefuehlt war jedes Upgrade mit einem NVIDIA-Problem einhergegangen. Das war aber noch in den Griff zu kriegen. Seit Leap 16 habe ich einfach zu viele Baustellen. Es sind im Wesentlichen Plasma/KDE-Probleme, KDE-Wallet-Katastrophe, fehlende neue Versionen in den Repositories, keine verlaessliche Unterstuetzung von Cloud-Speichern in Dolphin, ... Nach ein wenig Recherche werde ich jetzt Fedora (44.1.7) eine Chance geben.

==CLX LAB==
[[Datei:CLXLAB Icon.webp|mini|KI generierter Inhalt|100px]]

Heute habe ich die Idee eines virtuellen Labors mal verankert. So richtig weisz ich noch nicht wie es genau funktionieren soll, aber der Anfang ist gemacht.
Einfach ne eMail an tibb(at)clx.de und schon kann's losgehen. Notwendiges Hardware-Equipment kann ich zur Verfügung stellen.

Ich suche Mitarbeitende für folgende Projekte:
- Insect Detect
- Meshtastic
- Fox ESS API
- Victon Energy Cerbo GX Programming
uvm.

Fundierte Hard- und Softwarekenntnisse sind Voraussetzung.

20260101
[[Datei:Selbstlernautomation.png|100px|mini|KI generierter Inhalt]]
Playful robot mascot with tech emblem
Einen Gedanken, den ich ab 2026 mal intensiver verfolgen werde, ist der, ich nenne ihn mal, "'''Selbstlernautomation'''".
Nach meiner aktuellen Vorstellung bedeutet dies, die Realisierung eines Systemes (Regelungssystem, Roboter, Rover, ), welches bei moeglichst optimaler Hardwareanpassung (Aktuatoren, Sensoren) an die Umgebung und Aufgabe, unter zuhilfenahme von Erfahrungsdaten (Datenarchive, Wetterprognosen, ...), einen KI-basierten Regelungsmechanismus nutzt, um die gestellte Aufgabe besser als ein darauf geschulter Mensch zu erfuellen. Weiter geht's auf der Einstiegsseite im CLXLAB zu [[(CLXLAB) Selbstlernautomation|Selbstlernautomation]].

20260626
[[Datei:BASE73Logo.png|mini|100px|KI generierter Inhalt]]
Meine 'Virtual Lab' -Idee mit hybridem Makerspace hat jetzt eine eigene Heimat.

http://base73.tech

==Tipp des Tages==
2026-10-09

Mir war bisher nicht aufgefallen, dass ich hier beim TinkerTibb ja auch meine Cheat-Sheet-Sammlung einstellen kann. [https://tippvomtibb.de/mediawiki/Cheat_Sheets]

2026-07-09

Ich habe gelegentlich mehrere Monitore an einem Rechner. Davon steht der ein oder andere aber so, dass er nicht vom Arbeitsplatz einsehbar ist. Da hilft folgender Befehl um den Bildschirminhalt in einem Fenster auf dem Hauptmonitor zu sehen.

ffplay -f x11grab -video_size 1280x1024 -i :0.0+3840,0

Siehe Tipp[[(LinuxDesktop)_Screen/Monitor_im_Fenster]]

2026-07-27

deathbyclawd.com The SaaSpocalypse Survicval Scanner

siehe auch

replacebyclawd.com

==Fundstueck der Woche==
2026-09-14

Das Ding ist der Hammer! Live long and prosper! [https://www.youtube.com/watch?v=Sl_FQ-48mbw]

2026-07-26

Excalidraw ist einfaches digitales Whiteboard. Ich benutze bisher Miro, mal schauen.

2026-07-24

WhatsApp Kanal: Everlast AI

2026-07-09

Ahoylist https://ahoylist.net/ [https://github.com/yarrlist/AhoyList] eng verwandt mit https://yarrlist.net/

2026-07-06

Paketsender Send & receive TCP, UDP, SSL, DTLS. HTTP Requests. And Panel Generation. Ich werde die Software erst einmal beim Analysieren des MODBUS einsetzen.

2026-07-06

Mit dem Befehl nmap --script modbus-discover.nse --script-args='modbus-discover.aggressive=true' -p 502 192.168.178.xxx

kann man nach MODBUS-Clients scannen. Der genauen Funktion der nmap-Scripts werde ich eine eigene Seite widmen.

2026-06-28

https://orocos.org/ Das werde ich bei Gelegenheit mal genauer unter die Lupe nehmen.

2026-06-20

Ich habe mal ChatGPT eine Saarlandkarte anfertigen lassen. '''LOL''' z. B. St. Ingbert und Luxemburg

Das Ergebnis bestätigt meinen bisherigen Eindruck der LLMs.

Erstmal Wow und dann Upps!

(Ab sofort als Kurzform: [[Erst Wow dann Upps!]])

[[Datei:ChatGPT Image Jun 28, 2026, 12 22 42 PM.png|150px|KI generierter Inhalt]]
[[Datei:ChatGPT Image Jun 28, 2026, 12 23 03 PM.png|150px|KI generierter Inhalt]]

Auf die Fehler hingewiesen, wurde es daneben noch doller.

Das deutet schon darauf hin, warum so viele KI-Projekte scheitern werden.

2026-01-04

Sehr informative Wetterseite. [https://www.ventusky.com/de Ventusky]

2025-12-03
Und schon wieder Apple. Bei der Firma hat man wohl zu viele Sammeltassen im Schrank. Im Einstellungstest wird angeblich folgendes gefragt: In einer Klasse sind 24 Mädchen und 36 Jungen. Zusammen sind es 100. Wie kann das sein?
Da ist eine Personalchefin wohl übers Ziel hinausgeschossen. Mit mathematisch formal korrekten Angaben (Kennzeichnung der Wertangabe durch einen vertikalen Strich mit Hinweis auf das verwendete Zahlensystem) ist die Loesung simpel. Scheinbar knacken Schimpansen den Apple-Einstellungstest am besten.

2025-12-01
Und da sind sie wieder die Schimpansen. Diesmal bei Apple. Das kommt davon wenn man als Programmierer nur noch KlickiBuntis einstellt.

Bug in iOS: Bei iOS 16–17 gab es mehrfach das Problem, dass nur wenige Einträge angezeigt wurden, die Liste aber viel länger war.

2025-10-07
SuS kommen nach der 4. Stunde zum Lehrer. "Wir koennen unmoeglich jetzt den GLN schreiben!" "Unser Mathelehrer hat uns die ersten 4 Stunden gequaelt." "Wir sind jetzt zu keinem klaren Gedanken mehr faehig!"
Lehrer: "Ach Gott, was hat er denn mit euch gemacht?" SuS: "Irgendetwas mit 'T'!"
Lehrer: "Tangente?" SuS: "Nee, ich glaub Integral oder so."

2025-09-06

Schenkelklopfer im Buch "Factfulness" [https://en.wikipedia.org/wiki/Factfulness] erstes Kapitel: "Wissenschaftler, Schimpansen und Sie". Puh, nochmal Glueck gehabt.

2025-08-17

Nach Jahren mit [https://app.diagrams.net/ draw.io], [https://lucidchart.com lucidcharts], [https://miro.com/ miro] u. v. a. habe ich heute zum ersten Mal hier im Wiki ein Flussdiagramm mit [https://www.mermaidchart.com/ mermaid] und [https://graphviz.org/ GraphViz] mit Hilfe der [https://www.mediawiki.org/wiki/Extension:Kroki Kroki-Extension] integriert. Ich bin begeistert.

2025-06-20

1234 ist kein Passwort! Es ist eine PIN! lol

2025-06-08

Free Online OCR [https://tools.pdf24.org/de/ocr-pdf] Zum Konvertieren von Foto/Grafik nach Dokument, ohne sensiblen Inhalt, sehr praktikabel.

2025-05-25

Die genialste Erfindung der Chinesen war die GDPR (General Data Protection Regulation, DSGVO). Seit sie diese in die europaeischen Koepfe gepflanzt haben, ist ihr Technologievorsprung nicht mehr einzuholen.

2025-05-04

Online Tester fuer htaccess [https://htaccess.madewithlove.com/]

2025-01-05

Langweilst Du dich auch so, wie mich.

2025-01-03

So viel Schwachsinn hab ich in meinem Leben noch nicht gesehen und die meinen noch sie machens besonders gudd.
2024-09-06

The oldest computer was owned by Adam and Eve. It was an Apple. Only one wrong byte and everything was crashed!

2024-07-13

Der drollige Troll: drollig oder drollig?
*Drollig von Troll (nordisches Fabelwesen (ungehobelt, grob oder ungeschickt)) Hat eine leicht negative oder scherzhafte Konnotation.
*Drollig von Drol(l) (altdeutsch Possenreißer, Spaszmacher, (Hof-)Narr, Clown) Hat eine positive, niedliche oder humorvolle Bedeutung.

2024-06-28

Suno AI Explore [https://suno.com/explore] eignet sich durchaus als Radioersatz!.

2024-01-01

Nach einer (sehr) langen Suche nach einem (dauerhaft) hoerbaren Sender aus dem Groszraum Los Angeles:
Popstar!Radio Hollywood https://streaming.live365.com/a40380

2023-04-24

Ausbildungsklasse: Mechatroniker 
Thema: Kräftezerlegung 
Schuelerreaktion: Geben Sie (Lehrer) sich keine Muehe, Physik habe ich noch nie verstanden!

2023-04-21

Verzweifelter Lehrer im Lehrerzimmer nach der Korrektur eines Leistungsnachweises: 
Jetzt habe ich mit denen wochenlang Kraefteparallelogramme geuebt und die geben mir in der Klassenarbeit lauder Drache ab. Arrrrrr!

2023-01-28

"Meine Erfahrung zeigt, dass auf den groeszten Haufen immer noch einer drauf geschissen wird."

2022-11-16

„Wir leben alle unter dem gleichen Himmel, aber wir haben nicht alle den gleichen Horizont.“ Konrad Adenauer

2022-10-02

Logik-Simulator: [https://academo.org/demos/logic-gate-simulator/]

2022-08-04

Die Selbsthilfegruppe „UTF-8-Probleme“ trifft sich diesmal abweichend im grÃƒÂ¼nen Saal.

2021-04-03

"Bildung im 3D-Raum ist um einiges besser als Unterricht per Zoom-Call", sagt Ball. Cybersecurity-Experte Baggili stimmt dem zu: "Der wahre Mehrwert des Metaverses zeigt sich vor allem dann, wenn es dafür eingesetzt wird, unser Leben zu bereichern", sagt er.

[[Fundstücke Archiv]]

==Weisheiten aus dem Schulalltag==

'''Lehrer''': Lest euch zur Eingewoehnung in das neue Thema im Buch einmal die Seiten 42 bis 45 durch.

'''Schüler''': Wie 4 Seiten lesen! Das ist nicht Ihr Ernst.

'''Schüler''': Herr ... ! Das was Sie mit uns machen ist Quaelerei!
Frueher habe ich 3 Kopien bekommen, musste die für die Arbeit auswendig lernen, habe meine 1 bekommen und gut war.
Heute muss ich mir den Stoff selbst erarbeiten und den Quatsch fuer die Arbeit auch noch verstehen!

mehr -> [[Schenkelklopfer]]

==Die Leiden des Supporters==

[[Datei:LED Rotation Daumenhoch 7Seg 200.gif|mini]]

'''Kunde''': Das Ding tut nicht was es soll!

'''Supporter''': Haben Sie im Handbuch die Anleitung gelesen?

'''Kunde''': JA! Ziehen Sie den Nippel durch die Lasche und dann noch 10 Seiten Blabla.

'''Supporter''': Ja genau! Ihre Lösung steht im Blabla!

==Die drei großen Lügen der EDV-Administratoren==

# Ich weiß woran es liegt!
# Ich komme sofort!
# Jetzt funktioniert es wieder!

Variante 2:

1) Ich glaub, ich weiß, woran das liegt.

2) Ich komme gleich vorbei.

3) Jetzt sollte es funktionieren.

==3 Arten von Fehlern==
* '''Heisenbugs''': Fehler, die verschwinden, wenn man versucht, sie zu debuggen.
* '''Schrödingbugs''': Fehler, die nur auftauchen, wenn man versucht, etwas anderes zu debuggen.
* '''Mandelbugs''': komplexe Fehler, die sich mehr und mehr ins Chaotische steigern, je genauer man hinsieht.
Quelle: Damian Conway: Perl - Best Practices

==Elektrikerweisheit==

Strom macht ganz schnell klein, schwarz und haesslich ;)

==Ich werd bekloppt!==

Seit Jahren kämpfe ich als (Mathematik-)Lehrer gegen eine zunehmende Seuche, in der Sekundarstufe 2 (Klassen 10+). Jahr für Jahr können immer weniger Schueler mit mathematischen Formeln und Termen umgehen. Seit ein paar Jahren kommt noch hinzu, dass durch die Handy- und Tablet-Seuche immer weniger Schueler etwas mit einem PC anfangen koennen und das logische Denken beim Entwickeln von Algorithmen viele voellig ueberfordert. Folglich sind die Schuelerzahlen im Bereich Technik und Informatik stark ruecklaeufig.

Und jetzt finde ich durch Zufall diesen [https://scienceblogs.de/mathlog/2020/03/13/macht-mengenlehre-krank/ Artikel], weil einer meiner letzten Ideen war, mich notgedrungen in Mathematik von Zahlen und Buchstaben zu trennen und eine abstrakte Form des Umgangs mit (mathematischen) Zusammenhaengen zu suchen. Ich erinnerte mich an meine Grundschulzeit und die Mengenlehre.

Ich profitiere heute noch davon, in der Grundschule diesen "Mathematikunterricht" gehabt zu haben. Und wenn man die Kommentare unter dem Artikel liest, sind nicht wenige meiner Meinung und erstaunlicherweise viele scheinbar auch im Bereich der Softwareentwicklung taetig.
Ich lehne mich mal weit aus dem Fenster: "In der Grundschule braucht man in Mathematik nur Mengenlehre und Kopfrechnen als gesunde Basis!"

==Weisheiten zum Nachdenken==

Mit deinem Gehirn waere mir langweilig.

Neid ist die höchste Form der Anerkennung.

Geruechte sind oft Luegen mit Widerhaken.

Nichtbeachtung ist die hoechste Form der Missachtung.

==Spruch des Tages==

Die Worte hör' ich wohl, allein mir fehlt der Sinn. [[Die Worte hör' ich wohl, allein mir fehlt der Sinn.|->]]

Sturges Gesetz: „90 % von allem ist Schrott“ (original: Ninety percent of everything is crud)

Viele Programmierer produzieren Kot statt Code.

In jeder Besprechung braucht man mindestens einen Stusskompensator, sonst werden schlechte Ideen am Ende noch beschlossen.

Beim Nutzen von KI basierten Systemen gelten aehnliche Prinzipien wie in der Finanzwelt: Die Gebildeten machen Quantenspruenge der Erkenntnis, so wie die Reichen immer reicher werden, während Kreti und Plethi über zu wenig Geld jammern und stolz wie Oskar sind, wenn sie mithilfe von Bildgeneratoren einem Frosch Schamhaare auf den Kopf gezaubert haben.

Der o. g. Spruch kommt mir vor wie eine angepasste Form von: Der Laie staunt, der Fachmann wundert sich.

Holt mal einer den Pfarrer fuer die Reste des Deputys

Trivialitaeten sind des Kleingeists Himmelreich

==Kaffeespende==

Wer bei mir mal vorbei kommen moechte, dem spendiere ich einen Kaffee.

[https://citymapper.com/directions?startcoord=&endcoord=49.400455%2C7.17435&endname=%2F%2F%2Fbeginn.krippe.ortschaft BECOMEACOFFEE ;-)]

Wer unbedingt Geld los werden will, sollte das lieber jemandem geben, der es dringender benoetigt.

z.B. [https://www.paypal.com/DE/fundraiser/charity/3961454 world's education for kids e.V.]

Und nein ich stehe nicht in Verbindung mit einer der Spendenorganisationen und auch nicht mit [https://www.paypal.com/fundraiser/hub Paypal Spenden].

==Request for Comments==

<comments />

Cheat Sheets

2026-10-09T17:25:50Z

Chris T. Ludwig: /* PyCharm */

=Python=
<pdf page="1" width="850" height="600">File:Python_Cheat_Sheet_DE_A3-1.pdf</pdf>
<pdf page="2" width="850" height="600">File:Python_Cheat_Sheet_DE_A3-1.pdf</pdf>

=PyCharm=
<pdf page="1" width="850" height="600">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>
<pdf page="2" width="850" height="600">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>

=PyTorch=
<pdf page="1" width="850" height="600">File:PyTorch_Cheat_Sheet_DE_A3.pdf</pdf>
<pdf page="2" width="850" height="600">File:PyTorch_Cheat_Sheet_DE_A3.pdf</pdf>

Datei:PyTorch Cheat Sheet DE A3.pdf

2026-10-09T17:25:22Z

Chris T. Ludwig: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

Cheat Sheets

2026-10-09T17:11:22Z

Chris T. Ludwig: /* PyCharm */

Cheat Sheets

2026-10-09T17:11:05Z

Chris T. Ludwig: /* PyCharm */

Cheat Sheets

2026-10-09T17:10:41Z

Chris T. Ludwig: /* Python */

Cheat Sheets

2026-10-09T17:10:18Z

Chris T. Ludwig: /* Python */

=Python=
<pdf page="1" width="830" height="600">File:Python_Cheat_Sheet_DE_A3-1.pdf</pdf>
<pdf page="2" width="830" height="600">File:Python_Cheat_Sheet_DE_A3-1.pdf</pdf>

=PyCharm=
<pdf page="1" width="1000" height="707">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>

<pdf page="2" width="1000" height="707">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>