scikit-image: The AI Image Pipeline

Hallo, hier ist Alex von DEV STORIES DOT EU. scikit-image: Die AI Image Pipeline, Folge 1 von 5. Bevor ein Deep Learning Model ein Gesicht erkennen kann, muss es ein Grid aus Zahlen verarbeiten. Wenn du dieses Grid in der falschen Reihenfolge fütterst, lernt dein Model nichts und deine Verarbeitung wird extrem langsam. Die AI Image Pipeline: NumPy at the Core ist die Lösung, um dieses Grid richtig zu strukturieren. Wenn du ein Bild mit scikit-image lädst, bekommst du kein proprietäres Image-Objekt. Du bekommst ein Standard-N-dimensionales Array, bekannt als ndarray. Ein Bild ist einfach eine Matrix aus Pixeln. Weil es ein ganz normales NumPy-Array ist, kannst du jede Standardoperation nutzen, um die Image-Daten direkt zu slicen, zu maskieren oder zu manipulieren. Hier ist die wichtigste Erkenntnis. Die Art, wie scikit-image diese Arrays indiziert, bringt viele Developer ins Stolpern. In der Standardgeometrie benutzt du x- und y-Koordinaten, wobei x horizontal und y vertikal ist. scikit-image verzichtet darauf zugunsten der Matrix-Notation. Der erste Index ist die Row, was der vertikalen Position entspricht. Der zweite Index ist die Column, was der horizontalen Position entspricht. Wenn du ein Farbbild hast, ist der dritte Index der Color Channel. Ein Standard-zweidimensionales Farbbild ist eigentlich ein dreidimensionales Array, angeordnet als Row, Column, Channel. Angenommen, du bereitest einen Batch von Farbbildern vor, um sie in ein Convolutional Neural Network zu füttern. Dein Network erwartet einen bestimmten Shape. Wenn dein Bild 256 Pixel hoch und 256 Pixel breit ist, mit roten, grünen und blauen Channels, ist der Shape eines einzelnen Bildes 256, 256, 3. Aber ein Batch dieser Bilder fügt am Anfang eine vierte Dimension hinzu, die die Anzahl der Bilder repräsentiert. Wenn du scikit-image-Funktionen auf diese Daten anwendest, muss die Funktion wissen, welche Dimension die Farbwerte enthält, damit sie diese nicht als räumliche Daten verarbeitet. Das wird über das channel axis Argument geregelt. Indem du das channel axis Argument auf minus eins setzt, sagst du der Funktion, dass die Color Channels immer in der letzten Dimension des Arrays sind. Das stellt sicher, dass die Funktion die richtigen Farbdaten ansteuert, egal ob du ihr ein einzelnes Bild oder einen großen Batch mit zusätzlichen räumlichen Dimensionen übergibst. Das bringt uns zum Memory. Das ist der Teil, auf den es bei der Processing Speed ankommt. NumPy-Arrays werden in zusammenhängenden Memory-Blöcken gespeichert, standardmäßig in einer C-like Order. Das bedeutet, dass sich die letzte Dimension im Array-Shape im physischen Memory am schnellsten ändert. Bei unserem Standard-Image-Array aus Row, Column, Channel liegen die einzelnen Color Channels für einen einzelnen Pixel in deinem Hardware-RAM direkt nebeneinander. Wenn du Custom Code schreibst, um über diese Pixel zu loopen, musst du dieses Memory Layout respektieren. Die Regel ist absolut: Die rechteste Dimension deines Arrays sollte in der innersten Loop verarbeitet werden. Du iterierst über Rows in der äußeren Loop, dann Columns, dann Channels ganz innen. Wenn du das umkehrst und innen über Rows loopst, zwingst du die CPU, zwischen fragmentierten Memory-Adressen hin und her zu springen. Das zerstört die Cache Locality und macht deinen Code deutlich langsamer. Das Wichtigste, was du dir merken musst, ist, dass scikit-image keine horizontalen und vertikalen Koordinaten verwendet; es nutzt striktes Matrix-Indexing aus Row, Column und Channel. Und wenn du deine Loops genau an diese Memory Order anpasst, bleibt deine Data Pipeline schnell. Wenn du helfen willst, diesen Podcast am Laufen zu halten, kannst du die Show unterstützen, indem du auf Patreon nach DevStoriesEU suchst. Das war's für diese Folge. Danke fürs Zuhören und keep building!

Hallo, hier ist Alex von DEV STORIES DOT EU. scikit-image: Die AI Image Pipeline, Folge 2 von 5. Der häufigste Silent Bug in Computer Vision AI liegt nicht in der Neural Network Architecture. Es ist ein Data Type Mismatch. Du fütterst ein Bild in ein Model, der Code läuft ohne Errors zu werfen, aber die Outputs sind kompletter Garbage. Das passiert, wenn deine Libraries grundverschiedene Vorstellungen davon haben, wie ein Pixel numerisch dargestellt werden soll. Heute beheben wir dieses Problem mit dem Thema Speaking the Same Language: Dtypes und OpenCV. In scikit-image werden Bilder als Standard Numpy Arrays gespeichert. Die Zahlen in diesen Arrays verhalten sich jedoch je nach ihrem genauen Data Type unterschiedlich. Das Default Format von Webcams und Standard Image Files ist Eight-Bit Unsigned Integer, bekannt als uint8. Diese Werte reichen von null bis 255, wobei null absolutes Schwarz und 255 die Peak Intensity darstellt. Wissenschaftliche Image Processing Functions und Deep Learning Frameworks bevorzugen jedoch fast immer Floating-Point Numbers. In scikit-image erwartet ein Float Image, dass die Pixel Intensities in einem strikten Bereich skaliert werden, üblicherweise von null bis eins. Hier ist der entscheidende Punkt. Verwende nicht die astype Methode von Numpy, um deine uint8 Bilder in Floats umzuwandeln. Wenn du ein uint8 Array nimmst und einfach astype float aufrufst, ändert Numpy lediglich den zugrundeliegenden Memory Type. Ein heller Pixelwert von 255 wird einfach zu 255 Punkt null. Die Werte werden nicht neu skaliert. Wenn du dieses Array an eine scikit-image Function oder ein PyTorch Model übergibst, das die maximale Helligkeit bei eins Punkt null erwartet, explodiert die Mathematik. Deine Weißtöne werden plötzlich so behandelt, als wären sie 255 mal heller als der maximal mögliche Wert. Stattdessen musst du die Built-in Utility Functions von scikit-image verwenden. Die wichtigste heißt img_as_float. Diese Function prüft den Input Data Type und übernimmt das mathematische Rescaling automatisch. Sie komprimiert einen uint8 Bereich von null bis 255 sicher auf einen präzisen Float Bereich von null bis eins Punkt null. Data Types sind nur die halbe Miete. Du musst auch die Color Channels ausrichten, insbesondere wenn du Video aufnimmst. Wenn du einen Frame mit OpenCV einliest, gibt es dir ein uint8 Numpy Array. Aber OpenCV hat eine historische Eigenheit. Es speichert Color Channels in der Reihenfolge Blue Green Red, bekannt als BGR. scikit-image und die meisten modernen AI Models erwarten Red Green Blue, oder RGB. Wenn du vergisst, die Channels zu tauschen, sehen rote Äpfel blau aus und menschliche Haut wirkt völlig fremdartig. Du musst keine schwere OpenCV Color Conversion Function aufrufen, um das zu fixen. Da das Bild lediglich ein Numpy Array ist, kannst du einfaches Array Slicing verwenden. Du slicest das Array entlang seiner drei Dimensionen. Du nimmst alle Rows, alle Columns und gibst für die letzte Dimension, die die Color Channels repräsentiert, einen Step von minus eins an. Das sagt Numpy, dass es die Channels rückwärts durchlaufen soll, wodurch BGR im Memory sofort in RGB umgewandelt wird. Lass uns eine komplette Ingestion Pipeline für ein Deep Learning Model durchgehen. Zuerst greifst du dir einen Frame aus einem OpenCV Video Stream und erhältst ein uint8 BGR Array. Als Nächstes kehrst du die Color Channels mithilfe von Numpy Slicing um, um es in RGB zu konvertieren. Dann übergibst du dieses Array an img_as_float. Das Array ist nun eine Floating-Point Matrix, perfekt skaliert zwischen null und eins. Schließlich konvertierst du dieses cleane Numpy Array in einen PyTorch Tensor. Ein Neural Network kann dir nicht sagen, wenn seine Input Data falsch skaliert ist; es lernt einfach die falschen Patterns oder failt silently. Die Kontrolle deiner Data Types und Channel Orders direkt beim Ingestion Step stellt sicher, dass deine Pipeline auf einem soliden mathematischen Fundament steht. Das war's für diese Folge. Vielen Dank fürs Zuhören und keep building!

Hallo, hier ist Alex von DEV STORIES DOT EU. scikit-image: The AI Image Pipeline, Folge 3 von 5. Neural Networks sind hervorragend darin, Muster zu erkennen, aber sie merken sich auch gerne mal die spezifische Beleuchtung eines Raumes, anstatt des Objekts, das du eigentlich erkennen willst. Um das zu beheben, müssen wir die Varianz in unseren Datasets durch Kontrast, Exposure und AI Robustness standardisieren. Stell dir ein Dataset mit medizinischen Röntgenbildern vor, die aus einem Dutzend verschiedener Krankenhäuser stammen. Die Scans kommen von unterschiedlichen Geräten mit stark variierenden Kalibrierungen. Einige Bilder sind dunkel und matschig, andere hingegen ausgewaschen und hell. Wenn du diese Rohdaten in ein Neural Network fütterst, wird es wahrscheinlich auf die Lichtverhältnisse bestimmter Scanner overfitten, anstatt zu lernen, die zugrunde liegende Pathologie zu erkennen. Du musst die Exposure normalisieren, bevor das Training beginnt. Der erste Schritt bei dieser Standardisierung ist oft das Entfernen irrelevanter Informationen. Wenn nur die Struktur zählt, lenkt Farbe nur ab. Du kannst eine Funktion namens rgb to gray verwenden, um Farbbilder in Single-Channel Grayscale-Arrays umzuwandeln. Das reduziert die Dimensionalität deiner Daten und zwingt das Model, die reine Luminanz zu bewerten. Sobald du ausschließlich mit Luminanz arbeitest, musst du die Basishelligkeit in deinem gesamten Dataset angleichen. Hier kommt rescale intensity ins Spiel. Diese Funktion führt einen linearen Stretch auf deinen Bilddaten durch. Sie nimmt den dunkelsten Pixel und mappt ihn auf den niedrigstmöglichen Wert, wie null, und mappt den hellsten Pixel auf den höchstmöglichen Wert, wie zweihundertfünfundfünfzig. Jeder Pixel dazwischen wird linear skaliert. Hier ist die wichtigste Erkenntnis. Ein einfacher Minimum-to-Maximum-Stretch ist fehleranfällig. Ein einzelner toter schwarzer Pixel oder ein helles Artefakt von einem Staubkorn auf dem Sensor diktiert dann die gesamte Skala. Der Stretch komprimiert deine eigentlichen anatomischen Daten in ein schmales, nutzloses Band von Grautönen, nur um diesen einen extremen Outlier zu berücksichtigen. Um das zu lösen, nutzt du Percentile Clipping. Anstatt vom absoluten Minimum und Maximum zu stretchen, berechnest du das zweite und achtundneunzigste Perzentil der Pixelwerte in deinem Bild. Dann übergibst du diese Perzentile als deine Input Range an die rescale intensity Funktion. Die Funktion schneidet die extremen zwei Prozent der hellen und dunklen Pixel ab, setzt sie auf reines Weiß und reines Schwarz, und stretcht die restlichen sechsundneunzig Prozent der Daten linear. Das garantiert, dass der Großteil deiner Strukturdaten die volle Dynamic Range nutzt und zufällige Artefakte komplett ignoriert werden. Manchmal reicht ein linearer Stretch nicht aus. Du hast vielleicht ein Röntgenbild, bei dem die Daten zwar erfasst wurden, aber alle Pixel um ein paar spezifische Grautöne geclustert sind, wodurch das Bild flach wirkt und Details verdeckt werden. Dafür nutzt du equalize hist, was für Histogram Equalization steht. Histogram Equalization ist ein nicht-linearer Prozess. Anstatt nur die Grenzen zu stretchen, analysiert sie die Häufigkeit jedes Pixelwerts im Bild. Dann verteilt sie die häufigsten Intensitätswerte über das gesamte verfügbare Spektrum. Wenn ein großer Teil deines Röntgenbildes in einem schmalen Band dunkler Grautöne gefangen ist, zieht die Histogram Equalization diese Grautöne auseinander und weist ihnen neue Werte zu, die von Schwarz bis Weiß reichen. Das erhöht künstlich den lokalen Kontrast und macht feine Texturen und Grenzen sichtbar, die zuvor in den matschigen Bereichen des Scans verborgen waren. Dein Dataset mit diesen Techniken zu standardisieren stellt sicher, dass dein Model die tatsächliche Form und Textur des Motivs bewertet. Eine robuste Pipeline entfernt die irrelevante Varianz der Hardware-Kalibrierung und zwingt das Neural Network, das Signal anstatt des Rauschens zu lernen. Danke, dass du ein paar Minuten mit mir verbracht hast. Bis zum nächsten Mal, mach's gut.

Hallo, hier ist Alex von DEV STORIES DOT EU. scikit-image: Die KI-Bildverarbeitungspipeline, Folge 4 von 5. Ein Convolutional Neural Network erkennt eine Katze vielleicht perfekt. Dreht man die Katze aber auf den Kopf oder verschiebt sie um drei Pixel nach links, ist das Modell plötzlich komplett blind. Das behebst du mit geometrischen Transformationen für Data Augmentation. Bevor wir irgendetwas augmentieren, müssen wir die Baseline vorbereiten. Neuronale Netze brauchen feste Input Shapes. Das machst du mit der resize-Funktion in scikit-image. Du übergibst ihr ein Bild und deine gewünschten Output-Dimensionen, und sie streckt oder staucht das Pixel-Array mathematisch passend, wobei die neuen Pixelwerte automatisch interpoliert werden. Aber Resizing allein macht dein Modell anfällig für Overfitting. Es merkt sich genau, wo Objekte im Frame sitzen. Um das zu verhindern, baust du eine Data Augmentation Pipeline, die on the fly zufällige Transformationen auf Trainingsbilder anwendet. In scikit-image manipulieren räumliche Transformationen den Koordinatenraum des Bildes mithilfe von Matrix-Mathematik. Ein Bild zu bewegen oder zu rotieren bedeutet, seine Pixelkoordinaten mit einer Transformationsmatrix zu multiplizieren. Hier ist die entscheidende Erkenntnis. Translation, also das Verschieben eines Bildes über die X- oder Y-Achse, kann nicht mit einer Standard-Zwei-mal-Zwei-Matrixmultiplikation berechnet werden. Matrixmultiplikation übernimmt Scaling und Rotation, aber das Verschieben erfordert Addition. Um das zu lösen, verwendet scikit-image homogene Koordinaten. Indem an jeden zweidimensionalen Punkt eine dritte Dummy-Koordinate, eine Eins, angehängt wird, erweitert das System die Mathematik. Dadurch können Translationen, Rotationen und Scaling alle gleichzeitig als eine einzige Drei-mal-Drei-Matrixmultiplikation berechnet werden. Du musst diese Drei-mal-Drei-Matrizen nicht manuell schreiben. scikit-image bietet Transformation Classes, die die Mathematik für dich erledigen. Für unsere Anti-Overfitting-Pipeline nutzt du die Euclidean Transform Klasse. Eine euklidische Transformation behält Abstände und Winkel bei, was bedeutet, dass sie nur Rotation und Translation übernimmt. Du initialisierst sie, indem du einen Rotationswinkel und einen Translationsvektor übergibst. Wenn du Shearing hinzufügen oder die Scale ändern müsstest, würdest du auf eine Affine Transform umsteigen. Wenn du eine Änderung der Perspektive simulieren müsstest, würdest du eine Projective Transform verwenden. Aber für zufällige Drehungen und Verschiebungen ist Euclidean genau das, was du brauchst. Sobald deine Transformationsmatrix definiert ist, musst du sie auf dein Bild anwenden. Das machst du mit der warp-Funktion. Du übergibst der warp-Funktion dein Input-Bild und dein Euclidean Transform Objekt. Hier wird es interessant. Die warp-Funktion berechnet nicht, wo die Input-Pixel im neuen Bild landen sollen. Wenn du Pixel vorwärts in ein neues Grid schiebst, erzeugt die Rotationsmathematik gebrochene Koordinaten. Wenn diese auf das nächste ganze Pixel gerundet werden, hast du am Ende fehlende Pixel, oder Löcher, die über dein Output-Bild verstreut sind. Stattdessen arbeitet warp rückwärts. Es nimmt die Inverse deiner Transformationsmatrix. Es schaut sich jede leere Pixelkoordinate im Target Output-Bild an, mappt sie rückwärts in den ursprünglichen Bildraum und interpoliert den korrekten Farbwert. Dieses Inverse Mapping garantiert einen soliden, lochfreien Output. Für deine Augmentation Pipeline ist die Logik simpel. Generiere einen zufälligen Winkel und ein zufälliges Set an Verschiebungen. Füttere sie in eine Euclidean Transform. Übergib diese Transform und dein Trainingsbild an die warp-Funktion. Der Output geht direkt in dein Neural Network. Geometrische Transformationen erzeugen nicht nur mehr Trainingsdaten; sie zwingen dein Modell dazu, das Objekt, das es erkennen soll, von den willkürlichen Koordinaten zu trennen, die es gerade belegt. Das war's für diese Folge. Danke fürs Zuhören und keep building!

Hallo, hier ist Alex von DEV STORIES DOT EU. scikit-image: Die AI Image Pipeline, Folge 5 von 5. Deep Learning Segmentation Models sind unglaublich leistungsstark, aber sie sind extrem hungrig. Sie verlangen Tausende von pixelperfekten, handgezeichneten Masks, bevor sie überhaupt etwas lernen können. Classical Segmentation zum Bootstrappen einer AI schließt diese Lücke. Du trainierst ein modernes U-Net, um Zellen oder Münzen zu erkennen, die sich berühren. Du brauchst Ground-Truth-Labels. Diese Masks von Hand zu zeichnen, dauert Wochen. Du könntest versuchen, einen einfachen Edge Detector wie Canny laufen zu lassen, um den Prozess zu automatisieren. Canny ist hervorragend darin, scharfe Übergänge zu finden, aber er scheitert oft daran, Loops zu schließen. Er liefert dir fragmentierte Outlines, keine soliden Regionen. Eine AI, die auf kaputten Outlines trainiert wurde, wird auch kaputte Outlines ausgeben. Region-based Segmentation löst dieses Problem. Genauer gesagt, der Watershed-Algorithmus. Er behandelt dein Bild wie eine topografische Landschaft. Hohe Pixelwerte sind Berge, und niedrige Werte sind Täler. Hier ist die entscheidende Erkenntnis. Anstatt zu versuchen, kaputte Edges zu verbinden, flutet Watershed das Bild von bekannten Startpunkten aus, bis sich das Wasser an den höchsten Kämmen trifft. Das garantiert geschlossene, solide Regionen. Zuerst baust du das Terrain. Das machst du, indem du eine Elevation Map mit einem Sobel-Filter generierst. Der Sobel-Filter berechnet räumliche Gradients und hebt Edges hervor. Wenn du ihn auf dein Bild anwendest, werden die Grenzen zwischen deinen überlappenden Münzen zu den hohen Kämmen in deiner Map. Die flachen Oberflächen der Münzen und der Background werden zu den Tälern. Als Nächstes platzierst du die Marker. Du musst dem Algorithmus sagen, wo das Wasser anfangen soll zu steigen. Wenn du das überspringst, flutet der Algorithmus von jedem winzigen lokalen Minimum aus und zersplittert dein Bild in Hunderte von unbrauchbaren Fragmenten. Du erstellst ein Marker-Array in exakt derselben Größe wie dein Originalbild. Du findest den definitiven Background, indem du Pixel unter einem bestimmten Intensity Threshold auswählst und ihnen den Wert eins zuweist. Dann findest du den definitiven Foreground, also die soliden Zentren der Münzen, indem du Pixel über einem höheren Intensity Threshold auswählst. Diesen weist du den Wert zwei zu. Schließlich triggerst du den Flood. Du übergibst deine Elevation Map und dein Marker-Array an die watershed-Funktion aus dem scikit-image Segmentation Module. Der Algorithmus füllt die Regionen, ausgehend von den Einsen und Zweien. Während das simulierte Wasser steigt, expandieren die Regionen. Wenn sie sich schließlich an den hohen Kämmen der Sobel Elevation Map treffen, baut der Algorithmus eine Boundary. Die Funktion gibt ein Integer-Array aus perfekt gelabelten, geschlossenen Regionen zurück. Sich berührende Objekte werden exakt an der Boundary getrennt. Du hast jetzt ein sauberes Mask-Array, in dem jede Münze ein eigenständiges, solides Objekt ist. Du kannst diese Pipeline über dein gesamtes ungelabeltes Dataset laufen lassen, um automatisch Tausende von Masks zu generieren. Diese Masks fütterst du dann direkt in dein U-Net als Ground-Truth Training Data. Das Bootstrappen einer AI erfordert keine menschliche Arbeit, wenn du weißt, wie man klassische Image Processing Terrain-Logik mit modernen Model Architectures kombiniert. Ich ermutige dich, die offizielle scikit-image Documentation zu erkunden und einfach mal hands-on eine Elevation Map zu bauen, und wenn du eine Idee für unsere nächste Serie hast, schau auf devstories.eu vorbei und lass es mich wissen. Das war's für diese Folge. Danke fürs Zuhören und keep building!