TippvomTibb - Letzte Änderungen [de]

(Pylontech) US2000 Lithium Battery

Chris T. Ludwig — Thu, 15 Oct 2026 12:38:12 GMT

LiIon/LiPo/LiFePO4 Zellen

(CAN) CAN-Bus & Co

Chris T. Ludwig — Mon, 12 Oct 2026 07:16:24 GMT

Bedienungsanleitung

← Nächstältere Version		Version vom 12. Oktober 2026, 09:16 Uhr
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 60:		Zeile 60:
	=Controllerboard CANUSB-OEM-ISO Interface Adapter Lawicell AB=		=Controllerboard CANUSB-OEM-ISO Interface Adapter Lawicell AB=

	~~= CANUSB-OEM-ISO =~~
	'''Recherchestand: 11. Oktober 2026.''' Die CANUSB-OEM-ISO ist die galvanisch getrennte Einbauplatine des LAWICEL CANUSB. Hersteller/Fertigung: ELMICRO Computer. Treiber, ASCII-Protokoll und API sind mit CANUSB kompatibel.<ref name="produkt">https://www.canusb.com/products/canusb-oem-iso/ – Hersteller-Produktseite, abgerufen am 11.10.2026.</ref>		'''Recherchestand: 11. Oktober 2026.''' Die CANUSB-OEM-ISO ist die galvanisch getrennte Einbauplatine des LAWICEL CANUSB. Hersteller/Fertigung: ELMICRO Computer. Treiber, ASCII-Protokoll und API sind mit CANUSB kompatibel.<ref name="produkt">https://www.canusb.com/products/canusb-oem-iso/ – Hersteller-Produktseite, abgerufen am 11.10.2026.</ref>

Zeile 68:		Zeile 67:
	*Keine externe Versorgung am CAN-Stecker einspeisen.		*Keine externe Versorgung am CAN-Stecker einspeisen.

			==Bedienungsanleitung==


			<pdf width="1000" height="300">File:Lawicell_canusb_manual.pdf</pdf>
			<pdf width="1000" height="300">File:LAWICEL_CANUSB_ASCII-Kommandos.pdf</pdf>

	== Platinenbilder ==		== Platinenbilder ==

Datei:LAWICEL CANUSB ASCII-Kommandos.pdf

Chris T. Ludwig — Mon, 12 Oct 2026 07:13:41 GMT

Chris T. Ludwig lud Datei:LAWICEL CANUSB ASCII-Kommandos.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:Lawicell canusb manual.pdf

Chris T. Ludwig — Mon, 12 Oct 2026 07:13:40 GMT

Chris T. Ludwig lud Datei:Lawicell canusb manual.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

(CAN) CAN-Bus & Co

Chris T. Ludwig — Mon, 12 Oct 2026 07:11:59 GMT

Controllerboard CANUSB-OEM-ISO INTERFACE ADAPTER TYP 122

@@ Zeile 58: / Zeile 58: @@
-=Controllerboard CANUSB-OEM-ISO INTERFACE ADAPTER TYP 122=
+=Controllerboard CANUSB-OEM-ISO Interface Adapter Lawicell AB=
 = CANUSB-OEM-ISO =
 '''Recherchestand: 11. Oktober 2026.''' Die CANUSB-OEM-ISO ist die galvanisch getrennte Einbauplatine des LAWICEL CANUSB. Hersteller/Fertigung: ELMICRO Computer. Treiber, ASCII-Protokoll und API sind mit CANUSB kompatibel.<ref name="produkt">https://www.canusb.com/products/canusb-oem-iso/ – Hersteller-Produktseite, abgerufen am 11.10.2026.</ref>
-'''Schnellanschluss:''' USB an den Computer; CAN_H an D-Sub-Pin 7, CAN_L an Pin 2, CAN_GND an Pin 3. Keine externe Versorgung am CAN-Stecker einspeisen. Windows und Linux verwenden dieselbe elektrische Belegung.
+'''Schnellanschluss:'''
 == Platinenbilder ==
-[[Datei:CANUSB-OEM-ISO_platine.jpg|thumb|600px|Herstellerfoto der Standardbestückung mit Mini-B und D-Sub9. Quelle: ELMICRO.]]
+[[Datei:CANUSB-OEM_ISO_platine.jpg|thumb|600px|Paltinenfoto der Standardbestückung mit Mini-B und D-Sub9]]
 == Eckdaten und Varianten ==
@@ Zeile 282: / Zeile 283: @@
 </pre>
 Typischer Port: /dev/ttyUSB0; bei mehreren Adaptern stabilen by-id-Pfad bevorzugen. Moderne Geräte verwenden FTDI-PID 6001, alte FFA8.<ref name="support" /> Kein ttyUSB-Port: USB-Datenkabel, Treiberbindung, PID und Zugriffsrechte prüfen. D2XX-Zugriff und ftdi_sio können um das Gerät konkurrieren.
 === SocketCAN mit slcand ===
@@ Zeile 360: / Zeile 367: @@
 <references />
-''Für die Referenzanzeige wird die MediaWiki-Erweiterung Cite benötigt. Bei fehlender Cite-Erweiterung die Quellen als gewöhnliche externe Links übernehmen. Die Seite benötigt keine Infobox-Vorlage oder SyntaxHighlight-Erweiterung.''
-''Originalunterlagen werden verlinkt; ihre vollständigen Texte sind nicht Bestandteil dieses Artikels.''
+=MCP2515=

Datei:CANUSB-OEM ISO platine.jpg

Chris T. Ludwig — Sun, 11 Oct 2026 16:41:37 GMT

Chris T. Ludwig lud Datei:CANUSB-OEM ISO platine.jpg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:CANUSB-OEM-ISO funktionsschema.svg

Chris T. Ludwig — Sun, 11 Oct 2026 16:27:47 GMT

Chris T. Ludwig lud Datei:CANUSB-OEM-ISO funktionsschema.svg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

(CAN) CAN-Bus & Co

Chris T. Ludwig — Sun, 11 Oct 2026 16:22:02 GMT

Eigenschaften

Änderungen zeigen

(Eco Worthy) Battery Charger 48V 50A

Chris T. Ludwig — Sun, 11 Oct 2026 14:57:32 GMT

Handbuch

← Nächstältere Version		Version vom 11. Oktober 2026, 16:57 Uhr
Zeile 7:		Zeile 7:

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


			=Fotos=

			<gallery>
			File:ECOWORTHY_Trafo_1.jpg
			File:ECOWORTHY_PCB_2.jpg
			File:ECOWORTHY_Typenschild_2.jpg
			</gallery>

Datei:ECOWORTHY Typenschild 2.jpg

Chris T. Ludwig — Sun, 11 Oct 2026 14:51:27 GMT

Chris T. Ludwig lud Datei:ECOWORTHY Typenschild 2.jpg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:ECOWORTHY PCB 2.jpg

Chris T. Ludwig — Sun, 11 Oct 2026 14:51:23 GMT

Chris T. Ludwig lud Datei:ECOWORTHY PCB 2.jpg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:ECOWORTHY Trafo 1.jpg

Chris T. Ludwig — Sun, 11 Oct 2026 14:51:21 GMT

Chris T. Ludwig lud Datei:ECOWORTHY Trafo 1.jpg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

(Eco Worthy) Battery Charger 48V 50A

Chris T. Ludwig — Sun, 11 Oct 2026 14:39:59 GMT

Handbuch

← Nächstältere Version		Version vom 11. Oktober 2026, 16:39 Uhr
Zeile 6:		Zeile 6:
	=Handbuch=		=Handbuch=

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

(Eco Worthy) Battery Charger 48V 50A

Chris T. Ludwig — Sun, 11 Oct 2026 10:28:35 GMT

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…“

Neue Seite

=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

Chris T. Ludwig — Sun, 11 Oct 2026 10:28:01 GMT

Chris T. Ludwig lud Datei:EcoWorthy BatteryCharger Manual korrigiert.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

KI Einführung in maschinelles Lernen mit Python und PyTorch

Chris T. Ludwig — Sun, 11 Oct 2026 08:45:44 GMT

Request for Comments

@@ Zeile 737: / Zeile 737: @@
 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.
 =Request for Comments=
 <comments />

Datei:Skript PyTorch Uebung3 Aufgabe1.png

Chris T. Ludwig — Sun, 11 Oct 2026 07:06:47 GMT

Chris T. Ludwig lud Datei:Skript PyTorch Uebung3 Aufgabe1.png hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

KI Vokabel

Chris T. Ludwig — Sun, 11 Oct 2026 06:34:09 GMT

In Convolutional Neural Networks (Dilated Convolutions)

← Nächstältere Version		Version vom 11. Oktober 2026, 08:34 Uhr
Zeile 714:		Zeile 714:

	[9] https://www.projectpro.io		[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

Chris T. Ludwig — Sun, 11 Oct 2026 06:33:38 GMT

Chris T. Ludwig lud Datei:Sigmoid-Fkt mit Ableitung.png hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

KI Vokabel

Chris T. Ludwig — Sun, 11 Oct 2026 05:39:16 GMT

CrossEntropyLoss

← Nächstältere Version		Version vom 11. Oktober 2026, 07:39 Uhr
Zeile 663:		Zeile 663:

	Die Accuracy ist nämlich nicht gut geeignet, um mittels Backpropagation die Gewichte eines neuronalen Netzes schrittweise zu verbessern.		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

Insect Detect

Chris T. Ludwig — Sat, 10 Oct 2026 11:43:23 GMT

Software

← Nächstältere Version		Version vom 10. Oktober 2026, 13:43 Uhr
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 453:		Zeile 453:
	python pytorchCUDAtest.py		python pytorchCUDAtest.py

	~~jupyter notebook~~		Das Modell liegt im Verzeichnis insect-detect-ml-main/models mit dem Namen efficientnet-b0_imgsz128.onnx

	~~python3~~.12 -~~m virtualenv env_yolov5~~		Visualisiert sieht es so aus. Siehe https://netron.app [https://tippvomtibb.de/WikiResources/efficientnet-b0_imgsz128.onnx]

			[Datei:efficientnet-b0_imgsz128.onnx.svg]

	=Links=		=Links=

Datei:Efficientnet-b0 imgsz128.onnx.svg

Chris T. Ludwig — Sat, 10 Oct 2026 11:39:28 GMT

Chris T. Ludwig lud Datei:Efficientnet-b0 imgsz128.onnx.svg hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

KI Modelldateiformate

Chris T. Ludwig — Sat, 10 Oct 2026 11:34:10 GMT

Allgemeines

← Nächstältere Version		Version vom 10. Oktober 2026, 13:34 Uhr
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 4:		Zeile 4:
	Eins vorab. Es sind wohl alle Formate ineinander konvertierbar.		Eins vorab. Es sind wohl alle Formate ineinander konvertierbar.

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

			Netron is a viewer for neural network, deep learning and machine learning models.

			Netron supports ONNX, TensorFlow Lite, PyTorch, torch.export, ExecuTorch, TorchScript, TensorFlow, Core ML, OpenVINO, Keras, Caffe, Darknet, Safetensors and NumPy.

			Netron has experimental support for MLIR, JAX, GGUF, RKNN, ncnn, MNN, PaddlePaddle and scikit-learn.

	=Die Formate im Überblick=		=Die Formate im Überblick=

KI Modelldateiformate

Chris T. Ludwig — Sat, 10 Oct 2026 11:11:54 GMT

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…“

Neue Seite

=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.

KI Vokabel

Chris T. Ludwig — Sat, 10 Oct 2026 10:27:27 GMT

Warum nutzt man heute dafür Deep Learning?

← Nächstältere Version		Version vom 10. Oktober 2026, 12:27 Uhr
Zeile 528:		Zeile 528:

	[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]		[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.

Mathematische Coprozessoren

Chris T. Ludwig — Sat, 10 Oct 2026 06:03:13 GMT

NVIDIA MicroArchitektur

← Nächstältere Version		Version vom 10. Oktober 2026, 08:03 Uhr
(7 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 46:		Zeile 46:

	=FPGA=		=FPGA=
			<pdf width=1000 height=300>File:fpga speziell tensor multiplikationen.pdf</pdf>

			TODO

			=NVIDIA MicroArchitektur=
			<pdf width=1000 height=300>File:uebersicht nvidia microarchitecture.pdf</pdf>

			TODO

			=Zahlenrepresentation und Genauigkeitsanspruch=
			<pdf width=1000 height=300>File:KI_f32fp64_int8.pdf</pdf>

Datei:KI f32fp64 int8.pdf

Chris T. Ludwig — Sat, 10 Oct 2026 06:00:29 GMT

Chris T. Ludwig lud Datei:KI f32fp64 int8.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:Uebersicht nvidia microarchitecture.pdf

Chris T. Ludwig — Sat, 10 Oct 2026 05:59:19 GMT

Chris T. Ludwig lud Datei:Uebersicht nvidia microarchitecture.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Datei:Fpga speziell tensor multiplikationen.pdf

Chris T. Ludwig — Sat, 10 Oct 2026 05:57:57 GMT

Chris T. Ludwig lud Datei:Fpga speziell tensor multiplikationen.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Mathematische Coprozessoren

Chris T. Ludwig — Sat, 10 Oct 2026 05:36:34 GMT

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…“

Neue Seite

=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 Operationen von den Grafikkarten, die ja nur als "Nebenprodukt" fuer allgemeine KI-Berechnungen herhalten muss, zu loesen, bin ich vermutlich nicht alleine.

Dann schauen wir mal.

=GPUs und ihre Cores=
{| class="wikitable sortable" style="text-align: left;"
|+ Vergleich der Kern-Bezeichnungen (Core Names) von NVIDIA, AMD und Intel
|- style="background:#efefef; font-weight:bold;"
! Hersteller !! Kern-Typ !! Offizieller Name (Marketing) !! Interne / Technische Bezeichnung !! Hauptaufgabe / Fokus
|-

| rowspan="3" | '''NVIDIA''' || Standard-Rechenkern || CUDA Core || ALU / SP (Streaming Processor) || Universelle Gleitkomma- (FP32/FP64) und Ganzzahlberechnungen (INT32).
|-

| KI- / Matrix-Kern || Tensor Core || Tensor Cores (verschiedene Generationen) || Spezialisierte Matrix-Multiplikationen für Deep Learning und KI (FP8, FP16, BF16, INT8, INT4).
|-

| Raytracing-Kern || RT Core || BVH Traversal / Triangle Intersection Unit || Beschleunigung von Lichtstrahlen- und Dreiecksberechnungen (Raytracing in Spielen/Rendering).
|-

| rowspan="3" | '''AMD''' || Standard-Rechenkern || Stream Processor (Stream-Prozessor) || Compute Unit (CU) / Dual Compute Unit / Work Group Processor (WGP) || Universelle mathematische Berechnungen (Grafik-Pipeline, FP32).
|-

| KI- / Matrix-Kern || AI Accelerator (ab RDNA 3) || Matrix Core (CDNA-Architektur für Rechenzentren) || Matrix-Operationen und Wellenform-Befehle (Wave Matrix Multiply-Accumulate / WMMA).
|-

| Raytracing-Kern || Ray Accelerator || Ray Accelerator (RA) || Dedizierte Hardware für Box-Sorting und Ray-Triangle-Schnittmengenberechnungen.
|-

| rowspan="3" | '''Intel''' || Standard-Rechenkern || Execution Unit (EU) / Xe-core || Vector Engine (XVE) || Standardmäßige Vektor- und Thread-Verarbeitung für Grafik und allgemeine GPU-Berechnungen.
|-

| KI- / Matrix-Kern || Intel XMX (Xe Matrix Extensions) || Matrix Engine (XME) || Hochleistungs-Matrix-Rechenwerke für KI-Skalierung (XeSS) und Deep Learning (DP4a, Systolic Arrays).
|-

| Raytracing-Kern || Ray Tracing Unit || Ray Tracing Unit (RTU) || Hardwarebeschleunigung für Bounding Box- und Primitiven-Tests (ab Xe-HPG / Arc-Grafikkarten).
|}

=FPGA=

Hauptseite

Chris T. Ludwig — Fri, 09 Oct 2026 17:27:51 GMT

Tipp des Tages

← Nächstältere Version		Version vom 9. Oktober 2026, 19:27 Uhr
Zeile 47:		Zeile 47:

	==Tipp des Tages==		==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		2026-07-09

Cheat Sheets

Chris T. Ludwig — Fri, 09 Oct 2026 17:25:50 GMT

PyCharm

← Nächstältere Version		Version vom 9. Oktober 2026, 19:25 Uhr
Zeile 6:		Zeile 6:
	<pdf page="1" width="850" height="600">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>		<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>		<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

Chris T. Ludwig — Fri, 09 Oct 2026 17:25:22 GMT

Chris T. Ludwig lud Datei:PyTorch Cheat Sheet DE A3.pdf hoch Datei hochgeladen mit MsUpload

Neue Seite

Datei hochgeladen mit MsUpload

Cheat Sheets

Chris T. Ludwig — Fri, 09 Oct 2026 17:11:22 GMT

PyCharm

← Nächstältere Version		Version vom 9. Oktober 2026, 19:11 Uhr
(3 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 4:		Zeile 4:

	=PyCharm=		=PyCharm=
	<pdf page="1" width="~~1000~~" height="~~707~~">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>		<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>
	<pdf page="2" width="~~1000~~" height="~~707~~">File:PyCharm_Cheat_Sheet_DE-1.pdf</pdf>

← Nächstältere Version		Version vom 15. Oktober 2026, 14:38 Uhr
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 21:		Zeile 21:
	Nennkapazität 50 Ah / 2,4 kWh		Nennkapazität 50 Ah / 2,4 kWh
	Nutzbare Kapazität (90% DoD) 45Ah / 2,2 kWh		Nutzbare Kapazität (90% DoD) 45Ah / 2,2 kWh
	Entladespannungsbereich 45,0 ... 54,0 V		Entladespannungsbereich 45,0 ... 54,0 V (Beachte: US3000C 44,5 ... 53,5 V)
	Ladespannungsbereich 52,5 ... 54,0 V		Ladespannungsbereich 52,5 ... 54,0 V (Beachte: US3000C 52,5 ... 53,5 V)
	Maximaler Entladestrom 100 A (2C) @ 15s.		Maximaler Entladestrom 100 A (2C) @ 15s.
	Maximaler Ladestrom 100 A (2C)@ 15s.		Maximaler Ladestrom 100 A (2C)@ 15s.
Zeile 81:		Zeile 81:
	! !!Li-Ion/LiPo!! LiFePO!!US2000 (Werte mal 15)		! !!Li-Ion/LiPo!! LiFePO!!US2000 (Werte mal 15)
	\|-		\|-
	\|Nennspannung\|\|3,6 V - 3,7 V\|\| 3,2 V\|\| ~~51,2 V (~~48 V ~~- 54,4 V)~~		\|Nennspannung\|\|3,6 V - 3,7 V\|\| 3,2 V\|\| 48 V
	\|-		\|-
	\|Ladeschlussspannung\|\| 4,2 V - 4,22 V\|\| 3,5 - 3,65 V (Herstellerabhängig) \|\| 56 V - 58,4V		\|Ladeschlussspannung\|\| 4,2 V - 4,22 V\|\| 3,5 - 3,65 V (Herstellerabhängig) \|\| 52,5 V - 54,75 V
	\|-		\|-
	\|Entladeschlussspannung\|\| 2,5 V - 3,0 V \|\| 2,0 V - 2,8 V (Herstellerabhängig) \|\| 32 V - ~~44,8~~ V		\|Entladeschlussspannung\|\| 2,5 V - 3,0 V \|\| 2,0 V - 2,8 V (Herstellerabhängig) \|\| 30 V - 42 V
	\|-		\|-
	\|Initialladung\|\| \|\| 3,8 - 4,0 V (Herstellerabhängig)\|\| 60 V - 64 V		\|Initialladung\|\| \|\| 3,8 - 4,0 V (Herstellerabhängig)\|\| 57 V - 60 V
	\|}		\|}

	Spannungsbereich: 3V - 3,4V pro Zelle		Spannungsbereich: 3V - 3,4V pro Zelle. Das bedeutet die "gesunde" Spannungsbereich laege zwischen 45 V und 51 V. Ich habe allerdings auch schon Empfehlungen fuer die Ladeschlussspannung von 52,5 V und auch vereinzelt auch 53,5 V gesehen.

	Eine Schutzabschaltung greift in der Regel bei ca. 3,8 V (60 V bei US2000).		Eine Schutzabschaltung greift in der Regel bei ca. 3,8 V (60 V bei US2000).