Logo der codecentric AG, einem in Deutschland führenden IT-Consulting Unternehmen

Logo der codecentric AG einem in Deutschland führenden IT-Consulting Unternehmen

Cloud-Native

Data & Machine Learning

Generative KI

Produktentwicklung

IT-Security

Leistungen

Arbeitsweise

Projekte

Berlin

Bielefeld

Dortmund

Erfurt

Frankfurt am Main

Hamburg

Karlsruhe

Leipzig

München

Münster

Nürnberg

Solingen

Stuttgart

Standorte

Blog

Softwerker

Fachmedien

Webinare

Events

Wissens-Hub

Unsere Kultur

Kultur & Karriere Podcast

Deine Entwicklung

Jobs

Karriere

Über uns

Aktuelles

Kontakt

International contact

Alle Standorte

Du hast Fragen oder möchtest dich mit mir austauschen? Gern – trag einfach deine Kontaktdaten ein.

Contact Us | Sub-Navi-Kontakt oder Zero Search Hits

Kontakt aufnehmen

Marketing & Community Management

Konntest du keine Einträge zu deinem Thema finden?  

STANDORT-TEAM

codecentric Bielefeld

Mitten in der Bielefelder Altstadt, direkt am Alten Markt, bauen wir passgenaue Software zur Lösung der Herausforderungen unserer Kunden. Agile Werte, insbesondere Zusammenarbeit auf Augenhöhe, sind dabei Basis unserer täglichen Arbeit. 

codecentric Team Bielefeld

Willkommen im Team Bielefeld

<p>Typischerweise sind bei Hackathons viele Soft- und Hardware-Entwickler zu finden, die innerhalb eines begrenzten Zeitraums versuchen, kreative und ungewöhnliche Lösungen in Form von Code und ersten Prototypen für vorher definierte Challenges zu erarbeiten. Beim BIE City Hackathon (<a href="http://www.bie-city.de" target="_blank">www.bie-city.de</a> ) der Open Innovation City Bielefeld und dem Digitalisierungsbüro der Stadt Bielefeld wurden davon abweichend auch insbesondere Nicht-Techies eingeladen, um die kollektive Intelligenz einer Stadt zu nutzen – zur Generierung und Findung von Ideen für die Herausforderungen einer Stadt im neuen Alltag mit COVID-19. Als Teilnehmerin und Mentorin konnte ich einige spannende Lösungsansätze in ihrer Entstehung begleiten. Die zu lösenden Probleme kamen aus den Bereichen Breitensport, Einzelhandel, Kunst und Kultur, öffentlicher Raum, Mobilität und Gastronomie.</p><h2>Die Challenge</h2><p>Mein eigenes Team hat die Herausforderung der Erkennung und Vermeidung von überfüllten Plätzen und einem verantwortungsvollen Miteinander bearbeitet. Überfüllte Plätze sind in der aktuellen Pandemie- und in den alltäglichen Situationen eine besondere Herausforderung für die Stadt und ihre BürgerInnen. Aktuell steigert ein hohes Menschenaufkommen auf begrenztem Raum das Ansteckungsrisiko mit COVID-19. Zudem wird aber auch die Bevölkerungszahl in Bielefeld über Corona hinaus zunehmen – der Platz der Stadt bleibt aber begrenzt, was auch eine generelle Verringerung der Aufenthaltsqualität an öffentlichen Plätzen zur Folge haben kann.</p><h2><b>Unsere Lösung</b></h2><p>Unsere Lösung überzeugte die Jury und zeichnete sie als eine der beiden Gewinner-Lösungen aus. Neben der Freude über das Preisgeld haben wir die Hoffnung, dass die Lösung, die wie folgt aussieht, zeitnah realisiert wird:</p><ul><li> Wir zählen Personen im Bereich der Innenstadt, sowie an relevanten Orten und Verkehrsknotenpunkten (Haltestellen ÖPNV, Marktplätze, etc.) mittels Sensorik.</li><li> Die Daten zur Personendichte werden dann in Form einer Heatmap mit zusätzlichen Informationen veröffentlicht, z. B. auf den offiziellen Seiten der Stadt Bielefeld (<a href="http://www.bielefeld.de" target="_blank">www.bielefeld.de</a> ) und Bielefeld Marketing (<a href="http://www.bielefeld.jetzt" target="_blank">www.bielefeld.jetzt</a> ). Dabei wird das Personenaufkommen mittels Ampelsystem abgebildet und es werden noch nicht so stark besuchte Alternativen (Orte, Routen, Veranstaltungen) vorgeschlagen, aber auch Prognosen über die zukünftige Entwicklung der Personenzahlen ausgegeben.</li><li>Zusätzlich werden die Informationen an relevanten Orten mit Displays zur Verfügung gestellt und die Daten zu überfüllten Plätzen werden auch in der App von moBiel, dem Anbieter des öffentlichen Nahverkehrs in Bielefeld, beim Suchen nach Verkehrsverbindungen angezeigt.</li></ul><p><a href="https://media.graphassets.com/1c84f5JmQF6ezVdvcRiC"><img src="https://media.graphassets.com/1c84f5JmQF6ezVdvcRiC" alt="bie city hackathon" width="455" height="304" /></a> <i>Foto der Team-Leiter der beiden Sieger-Teams: rechts Helen Bielawa vom Team Sport, links Meike Wocken. (Foto: Open Innovation City).<br /> </i></p><h2><b>Umsetzung </b></h2><p>Generell basiert der Ansatz auf der Nutzung eines (inner)städtischen LoRaWans, welches die Sensoren zur Zählung der Menschen verbindet. LoRaWAN steht für <b>Lo</b>ng <b>Ra</b>nge <b>W</b>ide <b>A</b>rea <b>N</b>etwork und ist eine energieeffiziente Funktechnologie für die Datenübertragung insbesondere von Sensoren, Zählern, oder anderen Messinstrumenten. Die reinen Zähldaten werden über ein Gateway des LoRaWans ans Backend übermittelt und stehen dort mittels Open Data API zur Verfügung, um z.B. dann auf den Webseiten in Form einer Heatmap dargestellt zu werden.</p><p><a href="https://media.graphassets.com/cWOrw5xOR8yrpDU7fMfc"><img loading="lazy" src="https://media.graphassets.com/cWOrw5xOR8yrpDU7fMfc" alt width="371" height="209" /></a> </p><p>Aber wie zählen Sensoren Personen? Wir als Menschen können das durch einfache Beobachtung feststellen, ob es sich um ein hohes Menschenaufkommen handelt. Für unseren Prototypen zur Umsetzung der Lösung haben wir uns für den Einsatz einer Kamera entschieden, die erkennen soll, ob viele Menschen auf einem Platz zusammen kommen. D.h. der Sensor besteht aus einem Mikrocontroller (z. B. Raspberry Pi) plus Kamera. Auf dem Mikrocontroller läuft dann eine lokale Bilderkennung (KI-basiert), die Fußgänger, Radfahrer, Kinderwagen etc. erkennt und zählt.</p><p>Wichtig ist bei diesem Einsatz: Die Kamera speichert keine Bilder und gibt auch keine Bilder für die Auswertung weiter. Es ist keine Anbindung an das Internet oder eine Cloud erforderlich. Die Bilder werden sofort lokal ausgewertet und dabei analysiert die KI nur die einzelnen Pixel und deren Farbverläufe im Bild hinsichtlich bekannter Formen, die Menschen, Radfahrern oder Kinderwagen ähneln. Daher muss es bei dieser Lösung keine Datenschutzbedenken geben. Die einzigen Daten, die weitergegeben werden, sind die reinen Zählstände der erkannten Objekte und diese Datenweitergabe ist LoRaWan-basiert. Neben der Kameratechnik kann aber auch andere Sensortechnik zum Erkennen von Menschenmengen genutzt werden, beispielsweise Infrarot, Paxcounter oder Lichtschranken.</p><h2>Open Data</h2><p>Uns war es wichtig herauszustellen, dass unsere Lösung auch über die Corona-Zeit hinaus einen Mehrwert liefern wird. Wir legen viel Wert auf das Open-Data-Konzept, dass die Daten von jedermann verwendet werden können. Unsere Vision ist es, dass die Daten zu einer stärkeren Bürgerbeteiligung in der Stadtentwicklung führen werden, da transparent für alle Gruppen in der Stadt dargestellt wird, wie sich die Mobilität von Menschen ändert, aber auch wie Plätze angenommen werden. Somit können diese Daten (politische) Argumente liefern, mehr Platz für Menschen zu schaffen, z. B. durch die Sperrung von Straßen. Auch Geschäftsmodelle werden sich mithilfe dieser Daten ändern können, z. B. neue Angebote im Nahverkehr, dass beispielsweise der Einsatz von Bussen und Bahnen unter Berücksichtigung der wartenden Personen an den Haltestellen passiert.</p><p><a href="https://media.graphassets.com/oATZ8gTQat6Et8SRTuhg"><img loading="lazy" src="https://media.graphassets.com/oATZ8gTQat6Et8SRTuhg" alt="bie city hackathon" width="434" height="245" /></a> </p><h2>Die Orga des BIE City Hackathon</h2><p>Es war ein hundertprozentiger Remote-Hackathon, wobei neben dem Organisatoren-Team aber auch weitere Teilnehmer im Pioneers Club gehackt haben, dem Coworking Space, in dem auch das codecentric-Team Bielefeld sitzt. Dort saßen wir auf Distanz in den unterschiedlichen Konferenzräumen verteilt und haben gemeinsam mit weiteren remote arbeitenden Teammitgliedern an unseren Lösungen gearbeitet. Die Kooperation mittels Slack, Miro-Board und Zoom-Sessions hat sehr gut geklappt. Auf die zu erwartende hohe No-Show-Rate einer Remote-Veranstaltung hat das Orga-Team schnell und gut reagiert und hat die Teams passend zusammengestellt.</p><p>Es wäre schön, wenn diese Lösung über den Hackathon hinaus weiterverfolgt würde und die Hackathon-Organisatoren Open Innovation City Bielefeld und das Digitalisierungsbüro der Stadt Bielefeld dafür Sorge tragen würden, dass nächste Schritte in Richtung Umsetzung gemacht werden. Vielen Dank an die Organisatoren für den Hackathon und an mein Team Kim Simon Kreutz, Jürgen Große-Ophoff und Lill Bretz für die tolle Zusammenarbeit!</p>

BIE Spotty – unsere Lösung beim BIE City Hackathon

Die Bedeutung von künstlicher Intelligenz wächst in der heutigen Welt. Doch wie funktioniert KI? Es hat zumindest nichts mit Magie zu tun – auch wenn KI gerne damit assoziiert wird. 

Normalerweise beantworte ich diese Frage ausführlich bei uns im IT Consulting unseren Kunden und helfe ihnen dabei, die Potenziale der künstlichen Intelligenz zu erschließen. Doch aufgrund der wachsenden Relevanz von KI sowohl in der Arbeitswelt als auch der Gesellschaft bin ich der Ansicht, dass KI und Datenkenntnisse mittlerweile zu den grundlegenden Fähigkeiten gehören, die jeder Mensch in der heutigen Welt beherrschen sollte. Insbesondere junge Menschen leben in einem Technologie-geprägten Alltag (nur ein kleiner Auszug):

- Ihre Welt in den sozialen Medien ist gesteuert durch Empfehlungsalgorithmen 
- Texte formulieren sie mithilfe von ChatGPT
- Für den schnellsten Weg von A nach B wird ein online Routing-Planer befragt, um zu entscheiden, ob das Ziel zu Fuß, mit dem Rad oder mit ÖPNV optimal zu erreichen ist.

Im Januar 2024 habe ich daher einmal eine andere Rolle eingenommen und war nicht als IT Consultant unterwegs, sondern stand vor einer 12. Klasse des beruflichen Gymnasiums mit Schwerpunkt Betriebsinformatik am [Berufskolleg Werther Brücke](https://bkwb.de) in Wuppertal. In einem zweistündigen Workshop habe ich ein Grundverständnis für künstliche Intelligenz vermittelt. Schülerinnen und Schülern sollten verstehen, in welchen Bereichen KI Mehrwerte stiften kann, aber auch Risiken verstehen. Die Klasse kannte bereits Algorithmen und hatte den Begriff Machine Learning kennengelernt, doch es fehlte ihr der Zusammenhang und auch die Unterscheidung zwischen den drei Begriffen Algorithmus, Machine Learning und künstliche Intelligenz. 

**Was ist eine künstliche Intelligenz?**

Es war spannend, diese Frage durch Schülerinnen und Schüler beantworten zu lassen und zu sammeln. Anschließend hatten wir eine gemeinsame Definition erarbeitet und Methoden dazu sortiert. 

**Wie trifft eine KI selbständig Entscheidungen?**

Eine häufige Aufgabe von KI ist es, Dinge zu klassifizieren: Ist ein Werkstück kaputt, ja oder nein? Ist die E-Mail Spam, ja oder nein? Versucht jemand beim Online-Shopping zu betrügen, ja oder nein? Um zu erklären, wie eine KI Dinge klassifiziert, habe ich das Beispiel „Monkey Cards“ von <a href="https://www.aiunplugged.org/" target="_blank" rel="noopener noreferrer">aiunplugged.org</a> eingesetzt, die Beschreibung und Affendarstellungen findet ihr <a href="https://www.aiunplugged.org/german.pdf" target="_blank" rel="noopener noreferrer">hier</a>. Es handelt sich dabei um vereinfachte Comic-Abbildungen von verschiedenen Affengesichtern. Ein Teil davon waren freundliche, nicht beißende Affen. Der andere Teil gehörte zu beißenden Affen. 

Die dargestellten Affen wurden unterteilt in Trainings- und Testdaten. Gemeinsam mit der Klasse wurde überlegt, welche Merkmale innerhalb der Trainingsdaten zur Klassifizierung „beißender Affe“ und „nicht beißender Affe“ verwendet werden können. Das wurde in einen Entscheidungsbaum überführt. Anhand der Testdaten wurde gezeigt, dass unser Modell funktioniert und in der Mehrheit richtige Entscheidungen getroffen hatte, aber auch nicht perfekt ist.

**Was sind die Grenzen von KI?**

Um uns den Grenzen der KI anzunähern, habe ich dann ein Bild eines Affen gezeigt, dessen Merkmale deutlich von den Merkmalen der Trainingsdaten abgewichen ist. Es wurde schnell klar, dass eine KI bei unbekannten Merkmalen anfängt zu raten, um eine Entscheidung zu treffen. 

![IMG_7324.jpg](https://media.graphassets.com/2H3s9BKbSaGVhrvQ30mt)

Abschließend wurden Anwendungsfälle aus meiner beruflichen Praxis vorgestellt und in einem Gespräch über Begegnungen der Schülerinnen und Schüler mit KI in ihrem Alltag gesprochen. Mir war dabei wichtig, nicht nur theoretisches Wissen zu vermitteln, sondern auch die praktische Anwendbarkeit von KI-Kenntnissen. Die Schülerinnen und Schüler wurden von mir ermutigt, selber kreativ zu werden und innovative Lösungen für reale Probleme mithilfe von KI zu entwickeln. Sie hatten auch direkt die Möglichkeit dazu: Im Anschluss haben die Schülerinnen und Schüler mit der Bearbeitung ihrer praktischen Lernaufgabe begonnen, ein Lager-Assistenzsystems im Rahmen der Konzeption smarter Logistik-Prozesse zu programmieren. Ich bin gespannt auf die Ergebnisse, die hier entstehen werden!


Eine Einführung in das Thema künstliche Intelligenz für Schülerinnen und Schüler 

Standortleitung Bielefeld

Machine-Learning-Modelle bewerten – die Crux mit der Metrik

<p><br /> Machine-Learning-Technologien lassen sich erfolgreich und praxisnah im Unternehmensumfeld einsetzen. Ein konkreter, überschaubarer Anwendungsfall und somit fokussierter Einsatz von Machine-Learning-Modellen kann dabei echten Mehrwert generieren. Dieser Mehrwert hängt natürlich vom Anwendungsfall und der Performance der trainierten Modelle ab. Das heisst, es gilt zu klären wie gut ein Modell die jeweilige Herausforderung eigentlich unterstützten kann. In diesem Artikel möchte ich daher erläutern, wie sich die Bewertung der Performance gestaltet, insbesondere abhängig davon wie viele Testdaten überhaupt zur Verfügung stehen oder stehen sollten.</p><h2>Testdatenumfang</h2><p>Mit Hilfe eines zurückbehaltenen repräsentativen Test-Sets und verschiedener Metriken lassen sich Scores berechnen und die Modelle bewerten sowie vergleichen. Das Test-Set wird dabei vor dem Training zurückgelegt und zur Optimierung des Models weitere Validierung-Sets aus den verbleibenden Daten erzeugt.<br /> <a href="https://media.graphassets.com/EW7apzh9Qnu6zlijabfR"><img width="916" height="439" src="https://media.graphassets.com/EW7apzh9Qnu6zlijabfR" alt="Train-Test-Split beim trainieren von Machine Learning Modellen" /></a> <br /> Sind für den jeweiligen Anwendungsfall sinnvolle Metriken gefunden und zu erreichende Zielwerte definiert, stellt sich die Frage, inwieweit man den erreichten Werten eigentlich vertrauen kann. Schließlich können diese nur auf einer reduzierten Menge von Beispieldaten basieren. Wie viele Testdaten nun für eine aussagekräftige Bewertung nötig sind hängt von dem zu erreichenden Score und dem gewünschten Vertrauen in die Bewertung ab.<br /> Allerdings sind für das Sammeln und im Falle des Supervised Learning, das Labeln der Daten, oft manuelle Schritte nötig und stellen unter Umständen einen nicht zu unterschätzende Kostenfaktor dar. Das heisst, es gilt einen guten Trade-Off zwischen Vertrauen in die Bewertung und den zu erwartenden Kosten für das Sammeln und Aufbereiten der Testdaten zu finden.</p><h2>Anwendungsfall</h2><p>Zur weiteren Erläuterung greife ich auf das Beispiel des Artikels: <a href="https://blog.codecentric.de/2019/07/machine-learning-modelle-bewerten-die-crux-mit-der-metrik/" target="_blank">Machine Learning Modelle bewerten – die Crux mit der Metrik</a>  zurück.</p><p>„<em>Ein Hersteller von Trinkgläsern möchte in seiner Produktion defekte Gläser erkennen und aussortieren. Dazu soll ein Modell zur Bildklassifikation trainiert und eingesetzt werden. Die Datenbasis besteht aus Bildern von unversehrten und defekten Gläsern.</em>“ <a href="https://blog.codecentric.de/2019/07/machine-learning-modelle-bewerten-die-crux-mit-der-metrik/" target="_blank">[1]</a> </p><p>Die Anzahl der Bilder von defekten Gläsern sei hier sehr beschränkt, so dass mit gewissem Aufwand erst nach einiger Zeit Bilder von ca. 500 unversehrten und 500 defekten Gläsern zum Training und Testen der Modelle zur Verfügung stehen – insbesondere weil defekte Gläser in der Produktion eher selten auftreten. Aus diesen 1000 Bildern wird dann ein repräsentatives Test-Set vor dem Training zurückgelegt.</p><p>Wieviele Testdaten sind nun für eine aussagekräftige Bewertung nötig? Bzw. was bedeutet aussagekräftig in diesem Zusammenhang? Sind 10 % bis 20 % der Datenbasis in diesem Falle 100 bis 200 Bilder ausreichend?<br /> Sei nun in diesem Beispiel die Metrik <em>Accuracy</em> gewählt und das Modell erreicht nach ein wenig Training und Optimierung eine Performance von 80 % korrekter Klassifizierungen – auf einer Basis von 100 Testbildern.<br /> Zur Abschätzung wie vertrauenswürdig dieses Ergebnis eigentlich ist, können Bordmittel der Statistik zum Einsatz kommen.</p><h2>Vertrauensbereich</h2><p>Ob ein Bild vom Modell richtig bewertet wurde oder nicht, lässt sich als ein Experiment mit den zwei möglichen Ergebnissen <em>Erfolg</em> oder <em>Misserfolg</em> auffassen. Das Testen eines Models ist ferner eine Serie von gleichartigen unabhängigen Versuchen, so dass die Binominalverteilung bzw. deren Annäherung <a href="https://de.wikipedia.org/wiki/Satz_von_Moivre-Laplace" target="_blank">[2]</a>  an die Normalverteilung zur Einschätzung des Ergebnisses anwendbar ist.<br /> Inwieweit man nun dem ermittelten Wert „vertrauen“ kann, lässt sich mit Hilfe eines Vertrauensbereichs, dem Konfidenzintervall, darstellen.<br /> Der Nutzen eines Konfidenzintervalles liegt in der Möglichkeit, die Unsicherheit einer Stichprobe, beispielsweise ein Testlauf auf 100 Bildern, und der daraus resultierenden Schätzung zu quantifizieren. Schätzung deshalb, weil die Testdaten nur einen kleinen Teil der möglichen Datenmenge bzw. Grundgesamtheit darstellen und somit das Modell nur mit einem kleinem Teil von Daten und nicht mit allen jemals möglicherweise vorkommenden Daten getestet wurde.</p><p>„<em>Das Konfidenzintervall gibt den Bereich an, der bei unendlicher Wiederholung eines Zufallsexperiments mit einer gewissen Wahrscheinlichkeit (dem Konfidenzniveau) die wahre Lage des Parameters einschließt.</em>“ <a href="https://de.wikipedia.org/wiki/Konfidenzintervall" target="_blank">[3]</a> </p><p>Die Darstellung des Intervalls erfolgt dabei mit Hilfe eines unteren und oberen Grenzwertes und der Annahme die Testläufe seien ziemlich oft auf verschiedenen unabhängigen Testdaten-Sets gleicher Größe wiederholt worden. Sodass beispielsweise im Mittel in 95 % der gedachten Testdurchläufe die resultierenden Grenzwerte den ermittelten Score einschließen.</p><h2>Intervalle berechnen</h2><p>Die Grenzwerte lassen sich beispielsweise wie folgt berechnen <a href="https://de.wikipedia.org/wiki/Konfidenzintervall_für_die_Erfolgswahrscheinlichkeit_der_Binomialverteilung" target="_blank">[4]</a> :</p><p><img height="75" width="242" src="https://media.graphassets.com/Vpfu08UoQ6iTlqZ1OfUB" alt="Konfidenzintervall"/> </p><p>Wobei <em>p=1/Score</em>, <em>n</em> die Anzahl der Daten und <em>z</em> eine Konstante ist, die für das gewünschte „Vertrauen“ (Konfidenzniveau), aus der Standardnormalverteilungstabelle abgelesen werden kann. Gängige Werte sind beispielsweise:</p><table><tr><td><strong>Niveau</strong></td><td>90 %</td><td>95 %</td><td>97 %</td><td>99 %</td><td>99,5 %</td></tr><tr><td><strong>z</strong></td><td>1,28</td><td>1,64</td><td>1,96</td><td>2,33</td><td>2,58</td></tr></table><p>Das heisst, für das Konfidenzniveau 95 % ergibt sich bei 100 Testdatensätze und einem gemessenen Score des Modells von 80 % das Intervall: 72 % bis 88 %. Diese Spanne ist schon recht groß und für manche Anwendungsfälle wohl nicht genau genug.</p><h2>Die Crux</h2><p>Aber selbst bei der Verdoppelung der Testdaten auf 200 Datensätze ist das resultierende Intervall: 74 % bis 86 % nicht viel kleiner. Im folgenden Diagramm sind für das Konfidenzniveau 95 % ein paar weitere Beispiele für die Accuracy Scores von 80 %, 90 %, 95 % und 99 % sowie für die Testdatengröße 100, 200, 1000, 10000 dargestellt. Ab 10000 Datensätze berechnet sich ein Rahmen von +-1% und ist vielleicht akzeptabel für eine Score von 80 %.<br /> <a href="https://media.graphassets.com/6pPbgPlvS8qI2Po6GjXE"><img loading="lazy" width="700" height="502" src="https://media.graphassets.com/6pPbgPlvS8qI2Po6GjXE" alt="Machine Learning Modelle testen – Intervalle pro Score und Test-Set Größe" /></a> </p><p>Allerdings berechnet sich für ein Ergebnis von 85 % auf Basis von 100 Testdaten das Intervall zu 78 % bis 92 %. Es überdeckt damit auch einen Wert von 80 %. Das legt den Gedanken nahe, dass es unter Umständen möglich ist, mit weniger Trainingsdaten zu arbeiten und das Testdaten-Set besser auszustatten. Es ist schließlich möglich, dass bei einem schlechteren Score, beispielsweise durch ein Training auf weniger Daten, die Grenzwerte des Konfidenzintervalles den ursprünglich besseren Score immer noch mit einschließen.<br /> Ferner kann das Fokussieren auf die letzten Promille Verbesserung, ermittelt auf Basis einen kleines Tests-Sets, ein nicht zielführendes Unterfangen sein. Oder gar der Effekt eintreten, dass nach Aufstockung der Testdaten ein vorher vielleicht nicht so gut erscheinendes Modell besser abschneidet, als das durch einen unwesentlich höhere Score ursprünglich präferierte.<br /> Das heisst, eine Aussage über die Performance des Modells und Abgrenzung gegenüber anderen Modellen auf Basis einer überschaubaren Anzahl von Testdaten ist nur bedingt möglich.<br /> Allgemein gilt: Je größer die Stichprobe, aus der die Schätzung gezogen wurde, desto präziser ist die Schätzung und desto kleiner und besser das Konfidenzintervall.</p><h2>Fazit</h2><p>Letztendlich sollte die Bewertung eines Modells mit Augenmaß erfolgen und die Größe eines Test-Sets in die Bewertung mit einfließen. Gerade bei Ergebnissen, die sich nicht wesentlich unterscheiden, muss die Auswahl eines Modells nur anhand dieser Bewertungen nicht immer erfolgsvorsprechend sein. Ein Feldtest von mehreren, nicht eindeutig abgrenzbaren Modellen in der Praxis, beispielsweise durch A/B-Testing, kann dabei eine Entscheidung unterstützen.</p><h2>Referenzen:</h2><p>[1] codecentric blog, <a href="https://blog.codecentric.de/2019/07/machine-learning-modelle-bewerten-die-crux-mit-der-metrik/" target="_blank">Machine Learning Modelle bewerten – die Crux mit der Metrik</a> <br /> [2] Wikipedia, <a href="https://de.wikipedia.org/wiki/Satz_von_Moivre-Laplace" target="_blank">Satz von Moivre-Laplace</a> <br /> [3] Wikipedia, <a href="https://de.wikipedia.org/wiki/Konfidenzintervall" target="_blank">Konfidenzintervall</a> <br /> [4] Wikipedia, <a href="https://de.wikipedia.org/wiki/Konfidenzintervall_für_die_Erfolgswahrscheinlichkeit_der_Binomialverteilung" target="_blank">Konfidenzintervall für die Erfolgswahrscheinlichkeit der Binomialverteilung</a> </p>

Machine-Learning-Modelle bewerten – die Crux mit den Testdaten

<p>Die Qualität bzw. Nützlichkeit von Machine-Learning-Modellen lässt sich mit Hilfe von Testdaten und Metriken bewerten. Allerdings in welchem Umfang? Manuell, automatisiert, einmalig, regelmäßig? Manuell lassen sich die ersten Modelle als Ergebnis eines Proof of Concepts sicherlich noch überschaubar bewerten und vergleichen. Steigt die Anzahl der Modelle je nach Anwendungsfall in die Dutzende oder gar Hunderte und sind diese zudem noch beständig neu zu trainieren, skaliert das manuelle Vorgehen eher nicht mehr.<br /> Die Vorbereitung der Daten, das Training der Modelle sowie deren Bewertung lässt sich in Form von Machine-Learning-Pipelines automatisieren. Eine qualifizierte Bewertung der Daten oder eine Bewertung der Vorhersagegüte eines Modells hat aber seine Tücken – insbesondere in automatisierter Form.</p><div><a href="https://media.graphassets.com/u1DthoCTBaUSlhtMWTqM"><img src="https://media.graphassets.com/u1DthoCTBaUSlhtMWTqM" alt="Beispiel einer einfachen Machine-Learning Pipeline" width="1024" height="290" /></a> <p>Beispiel einer einfachen Machine-Learning-Pipeline</p></div><p>In der klassischen Softwareentwicklung haben sich zur Qualitätssicherung Unit-Test, Integration-Test, End2End-Tests etc. innerhalb von CI/CD-Pipelines etabliert. Bei der Erstellung von Machine-Learning-Modellen sind ebenso Maßnahmen nötig. Diese könne den Prozess vom Aufarbeiten der Rohdaten bis zum Ausliefern eines Modells begleiten und die Qualität eines Modells gewährleisten.</p><h2>Quality Gate</h2><p>Der Begriff ‚Quality Gate‘ stammt aus dem Projektmanagement und beschreibt die Einführungen von ‚Prüfpunkten‘ in den Projektablauf. Ziel ist es, die Projektlaufzeit in kürzere, überschaubare Abschnitte einzuteilen, um somit den Fortschritt nachhalten zu können. Dabei sind vorab pro Gate prüfbare Erfolgskriterien festzulegen.<br /> Ein Gate beinhaltet beispielsweise eine Liste von Zielen oder Qualitätsansprüchen an die resultierenden Artefakte am Ende einer Projektphase. Diese müssen erfüllt sein, bevor der nächste Abschnitt im Prozessablauf gestartet wird. Gegebenenfalls kann es beim Prüfen des Status allerdings auch zum Abbruch des Projekts kommen. Denn es wird transparent, dass wesentliche Eigenschaften nicht erreicht wurden oder sehr wahrscheinlich auch gar nicht mehr erreicht werden. Durch einen frühzeitigen Stopp eines Projekts lassen sich somit unter Umständen auch Zeit, Ressourcen und Geld sparen.</p><div><a href="https://media.graphassets.com/PacRfeuTgGG1JYoDV8fB"><img loading="lazy" src="https://media.graphassets.com/PacRfeuTgGG1JYoDV8fB" alt="Quality Gates im Projektablauf" width="1024" height="368" /></a> <p>Quality-Gates im Projektablauf</p></div><p>Im Machine-Learning-Kontext können Quality Gates als dezidierte Checks zwischen den einzelnen Schritten einer automatisierten Pipeline integriert werden und somit die Qualität der Artefakte im Prozess nachhalten und monitoren. Typische Artefakte sind hier die Roh- und aufbereiteten Daten sowie die trainierten Modelle.</p><h2>Daten</h2><p>Die Qualität der Daten ist die Grundlage, um überhaupt erfolgreich Machine-Learning-Modelle trainieren zu können. Die ersten Quality Gates widmen sich daher den Daten und stellen sicher, dass das Training der Modelle auf einer sinnvollen Datenbasis geschieht. Zunächst lassen sich die Rohdaten prüfen. Sie müssen den bisherigen Annahmen/Statistiken und Ausprägungen entsprechen, da sonst gegebenenfalls Korrekturen im Setup des Modells und Trainings nötig werden können.<br /> In der Regel ist die Aufbereitung der Rohdaten höchst individuell und unter Umständen aufwendig. Das heisst, es sind gegebenenfalls weitere Prüfpunkte zwischen den Aufbereitungsschritten, hier nicht dargestellt, einzusetzen.<br /> Darüberhinaus kann beispielsweise die Verteilung der Daten in den resultierenden Datensets getestet werden. Eine faire und repräsentative Verteilung der Daten sowie eine ausreichende Menge an Datensätzen in den Sets sollte gewährleistet sein. Ansonsten ist die Auswertungen auf möglichen Validierungs- und Testsets nur bedingt aussagekräftig <a href="https://blog.codecentric.de/2020/03/machine-learning-modelle-bewerten-die-crux-mit-den-testdaten">[1]</a> .<br /> Eine unzureichende Datenbasis führt eher nicht zu den erhofften qualitativ möglichst guten Modellen. Falls diese Gates nicht passiert werden, kann ein frühzeitiger Abbruch schon zu Beginn der Pipeline Zeit, Ressourcen und Geld sparen. Insbesondere, wenn diese Gates mit überschaubarem Aufwand eingeführt werden können.</p><div><a href="https://media.graphassets.com/xGvsEd3BTIqOxKtHwWbb"><img loading="lazy" width="1024" height="307" src="https://media.graphassets.com/xGvsEd3BTIqOxKtHwWbb" alt="Bespiele für Daten-Quality-Gates innerhalb einer Machine-Learning-Pipeline" /></a> <p>Bespiele für Daten-Quality-Gates</p></div><h2>Metriken</h2><p>Um die Qualität der Vorhersagen eines Modells in einer Pipeline bewerten zu können, ist ein Set an automatisch auswertebaren Kriterien obligatorisch. Idealerweise kommen dazu numerische Metriken zum Einsatz. Diese können auf Vorhersagen des Modells auf dem zurückgelegten Testset ausgewertet werden.<br /> Dabei hängen die möglichen Metriken sowie Grenzwerte natürlich vom jeweiligen Anwendungsfall ab. Beispielsweise gilt es bei einer Klassifikation einen guten Tradeoff zwischen Abdeckung und Präzision zu finden und zu definieren, ab welcher Vorhersagesicherheit eine Klasse als erkannt gilt <a href="https://blog.codecentric.de/2019/07/machine-learning-modelle-bewerten-die-crux-mit-der-metrik">[2]</a> . Sind adequate Metriken aber erstmal ausgewählt und die zu erreichende Resultate bzw. Grenzwerte definiert, können die Kriterien in einem ersten Quality Gate für das Modell automatisiert geprüft werden.<br /> Allerdings stellt sich natürlich die Frage: Lohnt der ganze Aufwand überhaupt, komplizierte Machine-Learning-Modelle einzuführen? Oder gibt es nicht auch einfacherer Alternativen, um die Anforderungen zu erfüllen?</p><h2>Baselines</h2><p>Eher rudimentäre Lösungen lassen sich mit Hilfe von einfacheren Modellen meist günstig und schnell realisieren. Diese Modelle können durch Heuristiken, einfachen Statistiken oder gar einer schlichten Generierung von Zufallswerten erstellt werden und sind in einem Test zu schlagen. Durch den Vergleich mit Baseline-Modellen bekommt man eine Idee davon, welche Leistung einfach zu erreichen ist. Dazu können Prognosen der Baseline und einem Modellkandidaten auf demselben Testset erstellt und mit den ausgewählten Metriken verglichen werden. Wie groß der Unterschied zu einer einfacheren Lösung ist, lässt sich somit verdeutlichen.<br /> Es sollte schon einen gewissen, letztendlich vorab zu definierenden Unterschied in der Leistungsfähigkeit zu Gunsten des komplexeren Modells geben, um den Einsatz zu rechtfertigen. Besteht Klarheit darüber, ab welchem Unterschied ein echter Mehrwert des ML-Ansatzes vorliegt, lässt sich dies als Kriterium nutzen und damit ein weiteres Gate in den Prozess integrieren. Wird die Baseline nicht geschlagen, sind weitere Optimierungen an den Daten oder dem Training nötig oder gar der gewählte Ansatz zu überdenken.</p><div><a href="https://media.graphassets.com/jd2d7GLTfeWchjFQnFQ6"><img loading="lazy" src="https://media.graphassets.com/jd2d7GLTfeWchjFQnFQ6" alt="Beispiele für Model Quality Gates innerhalb einer Machine-Learning-Pipeline" width="1024" height="426" /></a> <p>Beispiele für Model Quality Gates</p></div><h2>A/B-Tests</h2><p>Die eigentliche Performance des Models wird sich aber wohl erst in einer realen Situation, beispielsweise mit Hilfe von A/B-Tests, zeigen. <i>„Der A/B-Test (auch <em>split test</em>) ist eine Testmethode zur Bewertung zweier Varianten eines Systems, bei der die Originalversion gegen eine leicht veränderte Version getestet wird.“</i> <a href="https://de.wikipedia.org/wiki/A%2FB-Test" target="_blank">[3]</a> . Wenn die Infrastruktur es zulässt, können A/B-Tests ausgeführt werden und hilfreiche Einblicke liefern.<br /> Beispielsweise sind Korrelationen zwischen den zuvor geprüften Offline-Metriken und den Ergebnissen der Online-Metriken der A/B-Tests möglich. Es lässt sich damit einschätzen, inwiefern die Offline-Metriken die Performance der Modelle überhaupt vorhersagen können, bzw. welche am ehesten in Betracht gezogen werden sollten.<br /> Was unter Umständen vorab schon mal manuell ausgeführt und begutachtet werden kann ist ein A/B-Test zwischen einem ersten trainierten Modell und der Baseline.<br /> Darüber hinaus kann, wenn weitere Modell-Ansätze zu testen sind, natürlich auch das jeweils letzt beste Modell mit einem neuen potentiell besseren Modell verglichen werden. Der A/B-Test lässt sich damit auch als Quality Gate vor dem Deployment am Ende der Pipeline integrieren. Wobei A/B-Tests gegebenenfalls zeitaufwändig und somit automatisiert nicht immer praktikabel sind.</p><h2>Produktion</h2><p>Ein Unterschied zum Projektmanagement-Ansatz ist allerdings, dass der typische ML-Prozess in Zyklen verläuft. Letztendlich ist das Messen der Qualität eines Modells in den verschiedenen Gates innerhalb einer Machine-Learning-Pipeline nur eine Wette auf die Zukunft.<br /> Ist das Modell erst einmal in Produktion, unterliegt es einer gewissen Degeneration, welche je nach Domäne verschieden ausgeprägt und unterschiedlich schnell eintreten kann. Das heisst, Modelle veralten mit der Zeit und müssen gegebenenfalls an neue Gegebenheiten respektive Daten quasi angepasst werden. Dies kann beispielsweise durch erneutes oder weiteres Trainieren der Modelle erreicht werden, womit der Prozess von vorne beginnt.<br /> Quality Gates sind daher auch während des Betriebs der Modelle einzusetzen um festzustellen, ob das Modell in einer sich beständig ändernden Umgebung adequate Ergebnisse liefert bzw. weiterhin liefern kann.<br /> So können sich im Falle eines ‚Data Drift‘ zum einen die Daten ändern, beispielsweise die Verteilung oder Wertebereich der Daten bzw. Features. Oder die Muster, die das Modell gelernt hat, sind nicht mehr gültig und unterliegen einem Concept Drift <a href="https://en.wikipedia.org/wiki/Concept_drift" target="_blank">[4]</a> . Zum Beispiel können saisonale Effekte oder wie gerade geschehen in Zeiten einer Pandemie unerwartete Effekte die Vorhersagequalität von Modellen beeinflussen <a href="https://fortune.com/2020/09/23/a-i-algorithms-had-to-change-when-covid-19-changed-consumer-behavior" target="_blank">[5]</a> .<br /> Auch im Betrieb des Modells kann daher ein weiteres Gate regelmäßig neue Daten prüfen und verifizieren, dass sie den Annahmen noch entsprechen.</p><div><a href="https://media.graphassets.com/DdGU46q6QGGGTAWLgecV"><img loading="lazy" width="1024" height="397" src="https://media.graphassets.com/DdGU46q6QGGGTAWLgecV" alt="MachineLearning Quality-Gates-Kette" /></a> <p>Machine Learning Quality-Gates-Kette inklusive Monitoring der aktuellen Modellqualität</p></div><p>Wie oft ein Modell neu trainiert werden muss und welche Änderungen vorzunehmen sind, hängt vom Anwendungsfall und der Ausprägung der neuen Gegebenheiten ab. Ob es sich ferner überhaupt lohnt ist ebenso abzuschätzen, da gegebenenfalls die Kosten um neue Modelle zu trainieren nicht unerheblich sein können.<br /> Dieser Trade-Off zwischen Kosten und Nutzen oder sogar Kritikalität des Modells stellt ebenso ein Gate dar. Das Gate wird aber kurioserweise nur zum nächsten Schritt, des erneuten Trainings, geöffnet, wenn das Modell ’schlecht‘ genug ist.</p><h2>Fazit</h2><p>Wie hier beispielhaft dargestellt lassen sich Quality Gates an verschiedenen Stellen in einer Pipeline integrieren, um die Qualität der jeweiligen Artefakte eines Teilprozesses sicher zu stellen. Dazu müssen Erfolgskriterien, die zum Passieren eines Gates zu erfüllen sind, vorab definieret werden und automatisiert prüfbar sein.<br /> Ein frühzeitiger Stopp einer Machine-Learning-Pipeline kann Zeit, Ressourcen und Geld sparen. Denn durch das Fehlschlagen eines Gates ist absehbar, dass am Ende eine ausreichende Vorhersagegüte des Modells nicht mehr gewährleistet werden kann.<br /> Letztendlich sind Modelle auch in der Produktion zu überwachen, um eine mögliche Modell-Degeneration frühzeitig zu erkennen und entsprechend darauf reagieren zu können.<br /> Darüber hinaus können eine Reihe weitere Gates und Tests in Betracht gezogen werden, um zu gewährleisten, dass das Ökosystem rund um den Machine-Learning-Ansatz in der Praxis besteht. Dies geht allerdings über den Rahmen dieses Artikels hinaus, soll hier aber nicht unerwähnt bleiben <a href="https://storage.googleapis.com/pub-tools-public-publication-data/pdf/aad9f93b86b7addfea4c419b9100c6cdd26cacea.pdf" target="_blank">[6]</a> .</p><h2>Referenzen</h2><p>[1] <a href="https://blog.codecentric.de/2020/03/machine-learning-modelle-bewerten-die-crux-mit-den-testdaten">codecentric Blog – Machine-Learning-Modelle bewerten: die Crux mit den Testdaten</a> </p><p>[2] <a href="https://blog.codecentric.de/2019/07/machine-learning-modelle-bewerten-die-crux-mit-der-metrik">codecentric Blog – Machine-Learning-Modelle bewerten – die Crux mit der Metrik</a> </p><p>[3] <a href="https://de.wikipedia.org/wiki/A%2FB-Test">wikipedia – AB-Test</a> </p><p>[4] <a href="https://en.wikipedia.org/wiki/Concept_drift">wikipedia – Concept_drift</a> </p><p>[5] <a href="https://fortune.com/2020/09/23/a-i-algorithms-had-to-change-when-covid-19-changed-consumer-behavior">Fortune – A.I. algorithms had to change when COVID-19 changed consumer behavior</a> </p><p>[6] <a href="https://storage.googleapis.com/pub-tools-public-publication-data/pdf/aad9f93b86b7addfea4c419b9100c6cdd26cacea.pdf">Google, Inc. – The ML Test Score: A Rubric for ML Production Readiness and Technical Debt Reduction</a> </p>

Machine-Learning-Modelle bewerten – Quality Gates etablieren

<p>Auf dem Weg von einem Monolithen oder einer grünen Wiese zu einer Landschaft von Microservices sind viele Pfade zu beschreiten und Design-Entscheidungen zu treffen. Neben dem Aufbau fachlich sinnvoll abgegrenzter Serviceeinheiten gilt ein Augenmerk der Kommunikation der Services untereinander. Schließlich soll verhindert werden, dass am Ende nicht doch wieder ein Weg eingeschlagen wird, der zu einem Monolithen aus Services führt, der dann verteilt und fest verdrahtet im Rechenzentrum ruht. Womit das eigentliche Ziel, die lose Kopplung der Services zu erreichen, konterkariert wird.</p><div><a href="https://media.graphassets.com/6ltySSYRm2Df1z2F7r0d"><img width="700" height="249" src="https://media.graphassets.com/6ltySSYRm2Df1z2F7r0d" alt="Unter Umständen ungünstige Entkopplung von Komponenten einer Applikation" /></a> <p>Unter Umständen ungünstige Entkopplung von Komponenten einer Applikation</p></div><p>Eine Variante der fest verdrahteten und komplexen Kommunikation zwischen den Services zu begegnen liegt im Einsatz eines Mediators und der asynchronen Kommunikation zwischen den Services. Im Kontext einer Systemintegration kommt dabei als Mediator in der Regel ein Message Broker zum Einsatz. Das Request/Response Pattern, wie es bei gängigen Ansätzen (beispielsweise RESTful Services) Anwendung findet, wird ersetzt durch eine Nachrichten-basierte Kommunikation. Die Services übergeben einem Broker ihre Nachrichten und der Broker stellt den Empfängern die Nachrichten für eine definierte Zeit zur Verfügung. Wann und vom wem die Nachricht verarbeitet wird ist für den Nachrichtensender dabei völlig intransparent. Ferner erwartet der Sender auch keine Antwort, wie es bei einem synchronen Request/Response Verfahren der Fall wäre <a href="http://www.enterpriseintegrationpatterns.com/patterns/messaging/Introduction.html" target="_blank">[1]</a> .</p><h2>Event-Channel</h2><p>Diese asynchrone Kommunikation ist die Basis einer Event-driven Architecture (EDA) und wird durch einen Message Broker und das Publish/Subscribe Pattern als Event-Channel realisiert.</p><div><a href="https://media.graphassets.com/veagLw0RVC3zKnrSzoIg"><img loading="lazy" width="700" height="339" src="https://media.graphassets.com/veagLw0RVC3zKnrSzoIg" alt="Event-Channel" /></a> <p>Event-Channel zur Entkopplung der Komponenten und deren direkten Kommunikation miteinander – nicht zu verwechseln mit einem ESB</p></div><p>Der Publish/Subscribe-Ansatz ermöglicht darüberhinaus, dass eine Nachricht nicht nur von einem Service oder sonstigen Komponente gelesen wird, sondern von mehreren Konsumenten.</p><h2>Events vs. Commands</h2><p>Die übertragenen Nachrichten respektive Events enthalten keine Anweisungen bzw. explizite Kommandos wie es beispielsweise beim CRUD-Ansatz und dem direkten Ausführen von Aktionen der Fall wäre. Vielmehr beschreibt ein Event was geschehen ist.</p><blockquote><p> An event is a notable thing that happens inside or outside your business. </p></blockquote><p>So wird in einem E-Commerce Shop das Event <em>Customer Tom did a purchase.</em><br /> an einen Message Broker übermittelt, aber nicht eine Kette von Requests an RESTful Services abgesetzt, die Aktionen wie:</p><ol><li><em>Create a Cart Object for Customer Tom</em></li><li><em>Create an Address Object for Customer Tom</em></li><li><em>et cetera</em></li></ol><p> realisieren.<br /> Darüberhinaus sind folgende Aspekte und Bedingungen zu beachten:</p><ul><li>Ein Event enthält all die relevanten Daten, die von möglichen Kandidaten von Konsumenten benötigt werden um das Event sinnvoll verarbeiten zu können. So benötig ein Invoice-Service, der Toms Adresse auf die Rechnung schreiben muss, die Daten der Adresse.</li><li>Ein Konsument muß die Daten die er benötigt, selber vorhalten und aktualisieren. Das heist, der Invoice-Service wird Toms Rechnungsadresse bei einem Address-Service nicht explizit erfragen müssen – falls ein dedizierter Address-Service in dem System überhaupt existiert.</li><li>Die Konsumenten müssen Idempotenz gewährleisten, damit, falls ein Event mehrfach gelesen wird, es nicht zweimal berücksichtigt wird.</li><li>Die Daten in einem Event sind <em>immutable</em> – sie werden nicht geändert. Falls sich der Status der Daten ändert, ist ein neues Event zu erzeugen, das den neuen Datensatz inklusive der Änderungen beinhaltet.</li></ul><h2>Mindshift</h2><p>Die Einführung einer Architektur basierend auf <a href="https://www.codecentric.de/leistungen/loesungen/technologie-treibt-veraenderung/microservices/" target="_blank">Microservices</a>  erfordert schon ein gewisses Umdenken bei der Frage, wie welche Probleme zu lösen sind. Beispielsweise ist vom kanonischen Datenmodell Abstand zu nehmen, Bounded Contexts sind bei der Modellierung zu bevorzugen und Datenduplizierung kein No-go mehr.<br /> Bis zur Etablierung einer EDA sind, wie oben schon für Events beschrieben, eine Reihe Paradigmen und Gewohnheiten aufzugeben, mit ebenso großem Einfluß auf die Entwicklung. Insbesondere existiert:</p><ul><li>keine direkte Kommunikation – es wird nur durch Events kommuniziert was geschah. Der Sender weiß nicht, wer sein Event empfängt und wie der Empfänger den Inhalt nutzt.</li><li>keine Interaktionen basierend auf einem Callstack – es gibt keine zentrale Instanz, die durch synchrone Aufrufe von Subroutinen Prozesse Schritt für Schritt abarbeitet und den aktuellen Status in einem Prozess vorhält <a href="http://www.enterpriseintegrationpatterns.com/docs/EDA.pdf" target="_blank">[3]</a> </li><li>keine Service-Orchestration, sie wird abgelöst durch eine Service-Choreographie</li></ul><p>Allerdings ist eine EDA natürlich auch nur wieder eine weitere Möglichkeit Softwaresysteme aufzubauen und nicht der Weisheit letzter Schluß um jedwede Softwarelösung mit Hilfe dieses Architekturansatzes zu realisieren. Die finale Architektur wird eher polyglotter Natur sein und die EDA zum Beispiel nur einen Blick in die Systemlandschaft und Aktivitäten zur Laufzeit ermöglichen.</p><h2>Complex Event Processing & Event Stream Processing</h2><p>Liegt der Fokus beim Aufbau eine Systems aus Microservices zunächst nur darauf, die lose Kopplung mit Hilfe einer EDA zu arrangieren, geht allerdings ein nicht unwesentlicher Aspekt des EDA-Ansatzes unter – Complex Event Processing (CEP).</p><blockquote><p>Complex event processing is a new technology for extracting information from message-based systems. – David Luckham and Brian Frasca, 1998</p></blockquote><p>Die Möglichkeit, Events auf einer höheren Abstraktionsstufe ableiten zu können, sie regelbasiert zu verarbeiten oder Eventströme in Echtzeit zu monitoren, sind zentrale Merkmale die diesen Architekturansatz charakterisieren und antreiben.</p><table><caption>Eigenschaft einer Event-driven Architecture mit Complex Event Processing [4]</caption><tbody><tr><th>Eigenschaft</th><th>EDA mit CEP</th></tr><tr><td>Perspektive</td><td>Echtzeitfähigkeit</td></tr><tr><td>Ereignisverarbeitung</td><td>einfache und komplexe Ereignismuster (<em>event pattern matching</em>), unter Einbeziehung von Kontextinformationen (<em>content enrichment</em>)</td></tr><tr><td>Abstraktionsgrad</td><td>Abstraktion von einfachen zu fachlich höherwertigen Ereignissen ergibt Abstraktionshierarchie</td></tr><tr><td>Mengengerüst</td><td>Verarbeitung von Massenereignisdaten aus mehreren Ereignisströmen</td></tr><tr><td>Wissensrepräsentation</td><td>explizit in CEP-Komponente; Wissen über Ereignisverarbeitung deklarativ in Form von Regeln formuliert</td></tr></tbody></table><p>Der Begriff <em>Complex Event Processing</em> wurde dabei schon in den 1990er geprägt, wobei der heutzutage gern ins Spiel gebrachte Begriff, <em>Event Stream Processing</em> erst später aufkam und einen etwas anderen Fokus hat:</p><blockquote><p>Event stream processing is focused more on high-speed querying of data in streams of events and applying mathematical algorithms to the event data. Some of the first commercial applications were to stock-market feeds in financial systems and algorithmic trading. CEP is focused more on extracting information from clouds of events created in enterprise IT and business systems. CEP includes event data analysis, but places emphasis on patterns of events, and abstracting and simplifying information in the patterns. The idea is to support as wide an area of enterprise management decision making as possible. The first commercial applications were in the Business Activity Monitoring, for example monitoring conformance to service level agreements. <a href="http://www.complexevents.com/2006/08/01/what’s-the-difference-between-esp-and-cep/" target="_blank">[5]</a> </p></blockquote><p>Im folgenden soll Complex Event Processing den Ansatz des Event Stream Processing mit umfassen.</p><h3>Eventstruktur</h3><p>Um CEP zu ermöglichen, ist allerdings die Definition und Einführung systemweit gültiger Spezifikationen nötig. Zum Beispiel wird, wenn die asynchrone Kommunikation erst mal etabliert, Kommandos eliminiert und Nachrichten eingeführt sind, im nächsten Schritt eine zentrale Eventstruktur sowie ein Eventmodel zum Einsatz kommen müssen. Andernfalls ist eine regelbasierte Verarbeitung von Events nur umständlich zu erreichen.<br /> So sind zum Beispiel neben der eigentlichen Payload domänenunabhängige Meta-Daten wie:</p><ul><li>eine Event-Id – gewährleistet die eindeutige Unterscheidung von Events,</li><li>ein Event-Type – spezifziert den fachlichen Inhalt/Payload des Events,</li><li>ein Timestamp – Zeitpunkt des Auftretens des Events,</li><li>die Source – Komponente die das Event erzeugt hat</li></ul><p>unabdingbar, um ein Event für die Weiterverarbeitung einordnen zu können.<br /> Diese zentrale Struktur schränkt die gerade eingeführte Flexibilität bei der Interfacegestaltung der einzelnen Microservices aber schon wieder ein. Es ist daher abzuwägen inwieweit es sinnvoll ist, sich auf ein zentrales Konzept und Strukturen zur Verarbeitung von Events einzulassen – insbesondere wenn die „Autonomie“ der Services als ein hohes Gut betrachtet wird. Im Rahmen einer Makroarchitektur für ein System sind solche Strukturen aber durchaus diskutierbar. Insbesondere verlassen sich die Konsumenten neben den Meta-Daten schon auf eine feste Struktur; die der eigentlichen Payload. Durch die Struktur der Payload besteht weiterhin eine Kopplung zwischen einem Sender und den Empfängern seiner Nachricht.</p><h3>CEP-Lösungen</h3><p>Eine Übersicht über den derzeitigen Markt an CEP-Lösungen würde den Rahmen dieses Artikels sprengen, aber eine, insbesondere auch historische Übersicht, befindet sich auf complexevents.com <a href="http://www.complexevents.com/2016/05/12/cep-tooling-market-survey-2016/" target="_blank">[6]</a> .<br /> Die Einführung einer CEP-Enterpriselösung im großen Stil ist mit Aufwänden verbunden, die fachlich wie technisch zu rechtfertigen sind, und den Schritt hin zur EDA mit CEP und deren Vorteilen lohnen müssen.<br /> Das heisst es wird nicht immer sinnvoll sein, auf eine Enterpriselösung komplett umzustellen, insbesondere wenn der fachliche Kontext es gar nicht hergibt.</p><h3>Lightweight CEP – Beispiel</h3><p>Stehen die Events in einem Event-Channel zur Verfügung und besitzen diese die oben genannten Meta-Daten, ist der nächste Schritt, mit „komplexen“ Events zu arbeiten, nicht mehr weit.<br /> Der Aufbau einer leichtgewichtigen CEP-Lösung lässt sich dabei reduzieren auf die Komponenten [7]:</p><ul><li>Event processing agent (EPA) (event processing component, event mediator): A software module that processes events.</li><li>Event processing network (EPN): A set of event processing agents (EPAs) and a set of event channels connecting them.</li><li>Event processing language (EPL): A high-level computer language for defining the behavior of event processing agents.</li></ul><div><a href="https://media.graphassets.com/sSMMdtEUTeuFuHvteDii"><img loading="lazy" width="700" height="852" src="https://media.graphassets.com/sSMMdtEUTeuFuHvteDii" alt="Event Processing Agent and Network" /></a> <p>Event Processing Agents verarbeiten fachlich klar definierte Teilaufgaben und sind als ein Event Processing Network strukturierbar</p></div><p>Das folgende Beispiel basiert auf dem Open-Source-Projekte Esper <a href="http://www.espertech.com/esper-enterprise-edition/" target="_blank">[8]</a>  und Apache Camel <a href="http://camel.apache.org" target="_blank">[9]</a> . Esper stellt eine Processing Engine und eine Event Processing Language (EPL) zur Verfügung, um Events auf Event-Strömen beispielsweise filtern, aggregieren oder joinen zu können. Apache Camels Esper-Komponente ermöglicht eine standardisierte Integration der Esper Processing Engine um Events aus verschiedenen Quellen lesen und schreiben zu können. Ein Event Processing Agent lässt sich somit schon recht einfach realisieren und beispielsweise als Spring-Boot-Applikation deployen.<br /> Der folgende Sourcecodeausschnitt beschreibt eine Camel Route, die Events des Typs <em>CartCreatedEvent</em> beständig aus einem Eventstream ausliest und in einem Zeitfenster von fünf Sekunden auswertet. Falls der mittlere Umsatz während der fünf Sekunden geringer als 700 ist, wird ein neues Event <em>LowConversion</em> erzeugt und an den Event-Channel gesandt.</p><div>

```java5
from("esper://esper?eql=insert into de.codecentric.LowConversionEvent(avgTotalAmount) 
       select 
          avg(totalAmount) as avgTotalAmount 
       from 
          de.codecentric.CartCreatedEvent.win:time_batch(5 sec)
       having 
          avg(totalAmount) < 700
    ")
.to("seda:eventChannel");
```

</div><p>Die SQL-ähnlichen Queries sind dabei statisch und nur die Daten im Stream ändern sich. Das Vorgehen ist quasi umgekehrt zu einem Datenverarbeitungsansatz basierend auf einem RDBMS und SQL, bei dem die Queries meist recht variabel und die Daten eher statisch sind.<br /> Der Event-Channel ist hier realisiert als ein Topic eines Kafka-Brokers. Eine Camel-Route ließt die Events aus dem Topic und stellt sie der Esper Processing Engine als Objekte zur Verfügung (hier nicht dargestellt). Der Sourcecode sowie weitere Beispiele, inklusive Testdatenerzeugung und Kafka-Server-Einrichtung sind im GitHub Repository [10] verfügbar. Der Code enthält dabei natürlich nur die für die Beispiele relevanten Teile und Attribute und ist für einen produktiven Einsatz nicht ausreichend.</p><h3>Business Monitoring</h3><p>Sind die Events erst einmal im Event-Channel, lassen sich diese auch nach verschiedenen Kriterien monitoren und visualisieren – zum Beispiel mit dem Elastic-Stack, ehemals ELK Stack genannt <a href="https://www.elastic.co/de/products" target="_blank">[11]</a> . Dazu kann die Logstash-Komponente des Stacks die Events aus dem Kafka-Topic auslesen und dem Elastic Server zur Verfügung stellen. Die Events lassen sich dann nach verschiedenen Kriterien auswerten und mit Hilfe der Komponente Kibana visualisieren.<br /> Im folgenden Screenshot stellt das Tortendiagramm die Häufigkeit der einzelnen Events in Relation. Das Balkendiagramm zeigt einen Durchschnittswert über die <em>avgTotalAmount</em> der LowConversion Events und der Graph beschreibt einen Mittelwert der Umsätze der letzten Einkäufe. Automatische Aktionen zum Beispiel beim Über- oder Unterschreiten von bestimmten Grenzwerten sind dabei ebenso schon mit Esper Event-Listener und den Camel Routen realisierbar.<br /></p><div><a href="https://media.graphassets.com/KRcZ9D3nTpe5HaQrbEXS"><img loading="lazy" width="700" height="500" src="https://media.graphassets.com/KRcZ9D3nTpe5HaQrbEXS" alt="Kibana Screenshot" /></a> <p>Visualisierung von Events mit hilfe des ELK Stacks</p></div><p></p><h3>Performance</h3><p>Um der Herausforderung der möglichen schieren Masse an auftretenden Events und Performanceengpässen Herr zu werden, spielt die fachliche Aufbereitung eine nicht unwesentliche Rolle.<br /> Durch Event Processing Networks lassen sich komplexe fachliche Aufgaben strukturieren und in kleinere, fachlich klar definierte Teilaufgaben zerlegen. Diese Teilaufgaben sind dann durch leichtgewichtige skalierbare Agenten realisierbar. Ferner läßt sich durch das Filtern von Events und einer geschickten Strukturierung die Masse der zu verarbeitenden Events Schritt für Schritt reduzieren – was der Performance zuträglich sein wird. Darüberhinaus existieren mittlerweile eine ganze Reihe von Lösungen auch im Open-Source-Bereich, die gerade den Performance- und High-Availability-Aspekt adressieren [6] – siehe Distributed Stream Computing Platform (DSCP).</p><h3>Geht’s noch komplexer?</h3><p>Der Mitte der 90er Jahre aufgekommene EDA-Ansatz, damals in Kombination mit einer Service orientierten Architektur, kann als Kommunikationsbasis für Microservices zu einer weiteren Entkopplung der Services führen und Stabilität ins System bringen. Complex Event Processing ermöglicht darüberhinaus die Informationsverarbeitung auf neue Füße zu stellen und einen Einblick ins System zur Laufzeit zu geben. Das Design der Systeme wird aber unter Umständen komplexer, da ein kontrollierbarer Callstack nicht existiert und die Zusammenarbeit der Services nicht mehr orchestrierbar ist. Und somit mehr Aufwand entsteht den aktuellen Status eines inhärenten Prozessablaufs zu ermitteln.</p><h2>Referenzen</h2><p>[1] <a href="http://www.enterpriseintegrationpatterns.com/patterns/messaging/Introduction.html" target="_blank">EIP – Messaging</a>  <br /> [3] <a href="http://www.enterpriseintegrationpatterns.com/docs/EDA.pdf" target="_blank">Programming Without a Call Stack – Event-driven Architectures</a> <br /> [4] Event-Driven Architecture: Softwarearchitektur für ereignisgesteuerte Geschäftsprozesse, Xpert.press, ISBN 978-3-642-02439-9<br /> [5] <a href="http://www.complexevents.com/2006/08/01/what%E2%80%99s-the-difference-between-esp-and-cep/" target="_blank">Real Time Intelligence & Complex Event Processing</a> <br /> [6] <a href="http://www.complexevents.com/2016/05/12/cep-tooling-market-survey-2016/" target="_blank">CEP Tool Market</a> <br /> [7] Event Processing for Business: Organizing the Real-Time Enterprise, John Wiley & Sons, ISBN 978-0470534854<br /> [8] <a href="http://www.espertech.com/esper-enterprise-edition/" target="_blank">EsperTech</a> <br /> [9] <a href="http://camel.apache.org" target="_blank">Apache Camel</a> <br /> [10] <a href="https://github.com/codecentric/event-processing-sample">Event Processing Sample</a> <br /> [11] <a href="https://www.elastic.co/de/products" target="_blank">ELK Stack</a> </p>

Event-driven Microservices & Event Processing

<p><br /> Once a model has been trained, it can be evaluated in different ways and with more or less complex and meaningful procedures and metrics. However, the number and possible criteria for evaluating machine learning models can initially be quite confusing to someone who is just starting to deal with the field of machine learning.</p><p>For example, it depends on whether the learning is un-supervised or supervised. In the case of supervised learning it also depends on whether we are dealing with a regression or classification, the underlying use case, and so on – to name just a few criteria. I would like to start with supervised learning and classification. In this article I will introduce seven common metrics and methods for evaluating machine learning models using one example throughout this post. However, a detailed discussion would be beyond the scope of this introduction, so I will only touch only briefly on the mathematics underlying the metrics.</p><h2>Use case</h2><p>A manufacturer of drinking glasses wants to identify and sort out defective glasses in his production. A model for image classification is to be trained and used for this purpose. The database consists of images of intact and defective glasses. Intact glasses are represented by 0 in this binary classification; accordingly, defective glasses are represented by 1.</p><p>In the following test data (y_true), for example, eight defective and two intact glasses are present and seven of them are correctly classified as defective by the model (y_pred).</p>

```

# Test data  
y_true: [0, 1, 1, 1, 0, 1, 1, 1, 1, 1]

# Forecast/prediction of the model
y_pred: [0, 0, 1, 1, 0, 1, 1, 1, 1, 1] 

```

<h2>Accuracy</h2><p>Accuracy is probably the most easily understood metric and compares the number of correct classifications to all the classifications to be made.<br /> <img height="50"  src="https://media.graphassets.com/mMby3pjoROSlcrL8X2Kz" alt="Accuracy" /><br /> In the following example, only one value was wrongly predicted and therefore an accuracy of 90% was achieved.</p>

```

y_true:   [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]  
y_pred:   [0, 1, 0, 0, 0, 1, 1, 1, 1, 1]  
Accuracy: 90%.

```

<p>If the classes in the data are extremely unevenly distributed, viewing the accuracy alone can unfortunately lead to wrong conclusions. For example, if one class exists nine times more often in the data than the other, simply predicting the more frequent class is enough to achieve 90% accuracy – although the model may not be able to predict the other class. Whether the model is able to distinguish defective glasses from intact glasses is not assessable with this metric and a class distribution, since it always seems to predict a defective glass, as seen in the following example.</p>

```

y_true:   [0, 1, 1, 1, 1, 1, 1, 1, 1, 1]  
y_pred:   [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]  
Accuracy: 90%.

```

<p>In addition to such imponderables, it naturally also depends on the use case which metrics can be used for evaluating machine learning models.</p><h2>Binary classification</h2><p>First, a binary classification [1] can distinguish four cases:</p><ul><li> The class was predicted – which is correct (hit, true positive)</li><li> The class was not predicted – which is correct (reject, true negative)</li><li> The class was predicted – which is wrong (false alarm, false positive)</li><li> The class was not predicted – which is wrong (miss, false negative)</li></ul><p>For these four cases, however, different designations are common [2]. Since <em>hit</em>, <em>correct reject</em>, <em>false alarm</em> and <em>miss</em> seem to be most descriptive to me, I will use them here.</p><h2>Trade-Off between coverage and precision</h2><p>If, for example, it is important to recognize a class in the data as comprehensively as possible, the coverage (recall, hit rate, true positive rate) can be used as a quality criterion. Recall represents the number of <em>hit</em> in relation to the sum of <em>hit</em> and <em>miss</em>, i.e. all defective glasses to be detected:<br /> <img height="50"  src="https://media.graphassets.com/I2oWtxzOSwCpIDDEBEoG" alt="Recall" /><br /> If the model as above simply predicts a defective glass, i.e. only one class, the coverage is of course still hit=9 and miss=0 and thus Recall=9/$9+0$=1.</p><p>In contrast to this, precision describes the ratio of the number of <em>hit</em> to the sum of <em>hit</em> and <em>false alarm</em>, i.e. all glasses supposedly detected as defective:<br /> <img loading="lazy" height="50px" src="https://media.graphassets.com/PlIjHDjfTpK7cTSvrLro" alt="Precision" /><br /> At this point, predicting only one class would of course increase the number of <em>false alarm</em> to 1 and thus result in less precision – (Precision=9/$9+1$=0,9.</p><p>Finally, the coverage describes how many supposed hits there were and the precision how many were correct. Achieving both complete coverage and high precision is desirable. In practice, however, this will not always be possible and the focus will not always be on both. The F-measurement can be evaluated so that the two metrics do not have to be checked and weighed up against each other at the same time.</p><h2>F-measurement / F1-Score</h2><p>The F-measurement describes the harmonic mean between recall and precision and combines the two metrics to one value [3].<br /> <img loading="lazy" height="50"  src="https://media.graphassets.com/2AldbfclRQm7v7TyNYBh" alt="F1-Score" /><br /> The use of the harmonic mean means that the metric is somewhat more ‘sensitive’ to the smaller of the two values than it would be in the arithmetic mean.<br /> For example, a recall value of (1,0) and a precision value of (0,1) results in an arithmetic mean of 0,55 – which intuitively does not do justice to the small value of precision. However, the harmonic mean is calculated to 0,18 and points to a worse model.</p><p>The F1 score is derived from a more general variant, the F-beta score.<br /> <img loading="lazy" height="50"  src="https://media.graphassets.com/OzmPZIrShsy0eIRjiYIg" alt="F1-Beta Score" /><br /> With the F1 score, *beta* is set to 1 and thus recall and precision are weighted equally. If the application requires it, Recall and Precision can also be weighted differently. A (beta) value between 0 and 1 weights the precision more strongly, a value greater than 1 weights the recall more strongly.</p><p>However, even in this metric an unequal distribution of the classes in the data can falsify the result. In addition, the case <em>correct recject</em> is not considered in the F measure. A method would be desirable that considers all above mentioned cases of a binary classification, proves to be robust against unbalanced class distributions and is easy to represent.</p><h2>Confusion Matrix</h2><p>The comparison of the model’s predictions and the correct values in the form of a contingency table provides a more detailed insight into the model’s performance. For each case, the number of times it occurred in the result is counted, and the number is entered into a contingency table. The rows describe the predictions and the columns show the correct values. In the binary case this table is also called Confusion Matrix [2].<br /> The four cases can be found in this matrix, for example:<br /> <a href="https://media.graphassets.com/h1E1nzN1T9aHTzCAwtYQ"><img width="250" height="177" src="https://media.graphassets.com/h1E1nzN1T9aHTzCAwtYQ" alt="confusion matrix" /></a> </p><p>In the following example, the classes are not distributed equally but are in the ratio (7:3).</p>

```

y_true: [0, 0, 0, 1, 1, 1, 1, 1, 1, 1] 
y_pred: [0, 1, 1, 0, 1, 1, 1, 1, 1, 1]

hit = 6, false alarm = 2, miss = 1, correct reject = 1

```

<p>The model has six defective glasses correctly detected (hit) and one correctly classified as correct reject. However, two intact glasses were detected as defective (false alarm) and one defective glass was not detected (miss). The aim is to achieve the highest possible values in the matrix on the diagonal from top left to bottom right – i.e. high values only for <em>hit</em> and <em>correct reject</em>.</p><p>The matrix considers all cases, but keeping track is not always easy, and a statement about the performance of the model is intuitively not possible on the fly. Nevertheless, one gets an impression of how the results relate to each other. For example, the values that influence Recall and Precision can be found directly in the matrix.<br /> <a href="https://media.graphassets.com/sRIAzwPRDmxrzjCjbQCt"><img loading="lazy" width="250" height="177" src="https://media.graphassets.com/sRIAzwPRDmxrzjCjbQCt" alt="recall precision" /></a> </p><h2>Matthews Correlation Coefficient (MCC)</h2><p>A metric that summarizes all cases and is considered suitable for application to data sets with unbalanced class distributions is Matthews Correlation Coefficient [4,5,6]. It can be read and calculated from the Confusion Matrix as follows:</p><p><img loading="lazy" height="50" src="https://media.graphassets.com/2Lqr0BC5Rn2Iycx4Z6VA" alt="Matthew’s Correlation Coefficient" /></p><p>The value range of the metric is between -1 and 1. The value 1 is desirable, 0 is random, and negative values indicate a contradictory assessment of the model. However, the MCC is not defined if one of the four sums in the denominator is 0.</p><h2>The crux</h2><p>The values for Accuracy, Precision and Recall in the above example of the Confusion Matrix are:</p>

```

Accuracy:  0.70
Precision: 0.75
Recall:    0.86

```

<p>If we compare this model to another only on the basis of accuracy, this could already lead to the exclusion of the model at this point.<br /> A model with good accuracy and bad values for recall and precision could be preferable, but not necessarily the best model for this application. In this case, the metrics Recall and Precision, for example, would be more interesting, since they deal more precisely with the requirements and thus the model can be better assessed and compared.<br /> This means that pure confidence in accuracy can again lead to unfavorable conclusions about the performance of a model, depending on the application. This phenomenon is commonly known as the Accuracy Paradox [7].</p><p>In addition, depending on the distribution of classes in the data, some metrics may not represent changes in the predictions or may tend in different directions. The following examples give another small impression of how different the ratings can be.</p>

```

y_true:   [0, 1, 1, 1, 1, 1, 1, 1, 1, 1]   
y_pred:   [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]   
Accuracy: 0.90
F1 score: 0.95 (0.9474)
Matthews CC: 0.00

```

<p>With a value of >= 0.90, F1 and Accuracy already seem to be a quite good model. However, the Matthews Correlation Coefficient clouds the picture of the model and points to randomly correct predictions, since the intact glasses are extremely underrepresented and this one was even wrongly classified.</p><p>In the following case, undamaged glasses are more often present in the data and thus allow for a better evaluation.</p>

```

y_true:   [0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
  y_pred:   [1, 0, 1, 1, 1, 1, 1, 1, 1, 1]  
Accuracy: 0.90  
F1 score: 0.94 (0.9412)
Matthews CC: 0.67 (0.6667)

```

<p>Matthews Correclation Coefficient now points to a better model with a value of 0.67, since one of the two intact glasses was recognized correctly at least once. Accuracy and F1 do not react at all or only slightly to the change and they are calculated to the same or quite similar values as in the previous example. But will the decisions still be made by chance? After all, the two intact glasses are classified right in one case and once wrong in the other.</p><p>In the following example, three good glasses have been predicted twice correctly and once wrongly, so that the performance of the model can be evaluated even better. Matthews Correlation Coefficient acknowledges this with an increase from 0.67 to 0.76 and F1 with a further devaluation from 0.94 to 0.93.</p>

```

y_true:   [0, 0, 0, 1, 1, 1, 1, 1, 1, 1]  
y_pred:   [1, 0, 0, 1, 1, 1, 1, 1, 1, 1]  
Accuracy: 0.90  
F1 score: 0.93 (0.9333)
  Matthews CC: 0.76 (0.7638)

```

<p>This means that it is advisable to use the values of several metrics when comparing models and especially in case of unbalanced class distributions and to determine in advance which metrics are relevant for the application case.</p><p>However, what is the minimum score that we can be satisfied with regarding this model? This, of course, depends on the use case or the requirements and is often difficult to assess if there are no comparative variables such as the reliability of a human decision maker.<br /> Further graphical presentation of the performance of a model can be instructive and help achieve a good trade-off.</p><h2>Trade-Off between hit and false alarm rate</h2><p>While the glass manufacturer’s sales department strives to achieve the highest possible throughput in production, the quality and legal department will be more eager to minimize the number of defective glasses going on sale. This means that the sales department wants to avoid waste consisting of glasses unnecessarily classified as defective (false alarm). The quality assurance department, on the other hand, insists on recognising all defective glasses (hits) – even if this means that a few intact glasses cannot be sold.</p><h2>Receiver Operating Characteristic</h2><p>The Receiver Operating Characteristic curve (ROC curve) [8] compares the proportion of objects correctly classified as positive, i.e. the hit rate, with the proportion of objects falsely classified as positive, i.e. the false alarm rate, in a diagram. The false alarm rate describes the ratio of the number of glasses falsely detected as defective to the number of glasses detected as intact.<br /> <img loading="lazy" height="50" src="https://media.graphassets.com/vGF5YwjkRKqlfPm0z1ea" alt="False Alarm Rate" /></p><p>This means that the proportion of glasses correctly identified as defective is compared with the proportion of glasses falsely identified as defective.</p><p><a href="https://media.graphassets.com/4peAKHTkQHX5GsXoRFZn"><img loading="lazy" width="250" height="188" src="https://media.graphassets.com/4peAKHTkQHX5GsXoRFZn" alt="ROC Curve" /></a> </p><p>Additionally it is also a matter of optimizing a threshold value. Depending on the method used, the predictions of a model will not always only output the numbers 0 and 1 for classification. Rather, the values lie between 0 and 1 and thus describe a probability of belonging to a class, which is then to be interpreted. This means at what value do you want to accept that a class has been recognized?</p><p>The values of the hit rate are entered on the vertical per threshold value and the values of the false alarm rate on the horizontal. The diagonal from bottom left to top right describes the random limit. That means curves that tend far above this limit and into the upper left corner represent a good evaluation. The hit rate there is as high as possible and the false alarm rate very low at the same time. The result is this typical curve (black in the diagram) on which you can now decide which trade-off to enter, or – if you enter several models – which model can be used with which threshold value, or whether to continue training.</p><p>With the model in the following example (orange curve in the diagram), a hit rate of 0.86 could be achieved if a false alarm rate of 0.33 is accepted and a threshold value of 0.3 is applied. The thresholds themselves are not shown in the curve, but are listed in the following table.</p>

```

y_true: [0    0    0    1    1    1    1    1    1    1   ] 
y_pred: [0.22 0.24 0.40 0.23 0.30 0.42 0.70 0.50 0.60 0.80]

Hit rate:         [0.00 0.14 0.71 0.71 0.86 0.86 1.00 1.00]
 False alarm rate: [0.00 0.00 0.00 0.33 0.33 0.67 0.67 1.00] 
Thresholds:       [1.80 0.80 0.42 0.40 0.30 0.24 0.23 0.22]

```

<p>If you insist on a false alarm rate of 0, a hit rate of 0.71 is possible. For this purpose, the threshold value must be set to at least 0.42. In practice, of course, there are more data records available and correspondingly much finer gradations from which a threshold value can be selected. In addition, the area under the curve <em>Area Under Curve</em> AUC can be interpreted with a value between 0 and 1. In this case, 1 once again represents the best value and 0.5 represents the coincidence or in this case also the worst value [9]. The AUC values for the curves are listed in the key of the diagram.</p><h2>Evaluating machine learning models – Conclusion</h2><p>In general, you can try to train a model that achieves the best possible values for all metrics. In practice, however, the effort required to achieve the last per mille of improvement often does not justify the actual benefit. A pragmatic, application-oriented approach is more likely to lead to success and provides the necessary leeway to achieve a meaningful trade-off. After all, with the test results and the resulting metric values, the models can only be compared with each other. How good a model really is will then be shown in practice and a justification as to how the model came to its decision has not yet been given, but in some areas it may well be necessary [10].</p><p>But how much test data is actually necessary for a meaningful evaluation?<br /> Read in: <a href="https://blog.codecentric.de/en/2020/04/evaluating-machine-learning-models-test-data-sets/">Evaluating machine learning models: The issue with test data sets</a> ,<br /> what influence the size of the test data set can have on the comparability of models.</p><h2>References</h2><p>1] Wikipedia, <a href="https://de.wikipedia.org/wiki/Beurteilung_eines_bin%C3%A4ren_Klassifikators" target="_blank">Evaluation of a binary classifier</a> <br /> [2] Wikipedia, <a href="https://en.wikipedia.org/wiki/Confusion_matrix" target="_blank">Confusion Matrix</a> <br /> [3] TYutaka Sasaki, 2007, The truth of the F-measure  <br /> 4] Boughorbel S, Jarray F, El-Anbari M (2017) Optimal classifier for imbalanced data using Matthews Correlation Coefficient metric. PLoS ONE 12(6): e0177678. <a href="https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0177678" target="_blank">doi.org/10.1371/journal.pone.0177678</a> <br /> [5] Davide Chicco, 2017, Ten quick tips for machine learning in computational biology. <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5721660/" target="_blank">doi:10.1186/s13040-017-0155-3</a> <br /> [6] Wikipedia, <a href="https://en.wikipedia.org/wiki/Matthews_correlation_coefficient">Matthews correlation coefficient</a> <br /> [7] Wikipedia, <a href="https://en.wikipedia.org/wiki/Accuracy_paradox" target="_blank">Accuracy paradox</a> <br /> [8] Tom Fawcett, 2005, An introduction to ROC analysis, <a href="https://people.inf.elte.hu/kiss/11dwhdm/roc.pdf" target="_blank">doi.org/10.1016/j.patrec.2005.10.010</a> <br /> [9] Wikipedia, <a href="https://de.wikipedia.org/wiki/Receiver_Operating_Characteristic" target="_blank">Receiver Operating Characteristic</a> <br /> [10] Shirin Elsinghorst, Explanability of Machine Learning Methods, The Softwerker Vol. 13, <a href="https://www.codecentric.de/wissen/softwerker/" target="_blank">The Softwerker Vol. 13</a> </p>

Evaluating machine learning models: How to tackle metrics

<p><br /> Machine learning technologies can be used successfully and practically in a corporate environment. A concrete, manageable use case and thus focused application of machine learning models can generate real added value. This added value naturally depends on the use case and the performance of the trained models. Therefore it is important to clarify how well a model can actually support the respective challenge. In this article I would like to explain how the evaluation of the performance could be interpreted, especially depending on how much test data is or should be available.</p><h2>Test data scope</h2><p>By using a retained representative test set and various metrics, scores can be calculated and the models can be evaluated and compared. But the test set is not used in the training. To optimize the model, further validation sets are only generated from the remaining data.<br /> <a href="https://media.graphassets.com/EW7apzh9Qnu6zlijabfR"><img width="916" height="439" src="https://media.graphassets.com/EW7apzh9Qnu6zlijabfR" alt="Train-Test-Split when training Machine Learning models" /></a> <br /> Once meaningful metrics have been found for the respective use case and target values to be achieved have been defined, the question arises as to what extent the values achieved can actually be trusted. After all, these values can only be based on a reduced amount of example data. How much test data is necessary for a meaningful evaluation depends on the score to be achieved and the desired confidence in the evaluation.<br /> However, collecting and, in the case of supervised learning, labeling the data often requires manual steps and may be a cost factor that should not be underestimated. A good trade-off must be found between confidence in the assessment and the expected costs of collecting and preparing the test data.</p><h2>Use case</h2><p>For further explanation, I will use the example of the article: <a href="https://blog.codecentric.de/en/2019/09/7-common-metrics-evaluating-machine-learning-models/" target="_blank">Evaluating machine learning models: How to tackle metrics</a> .</p><p>“<em>A manufacturer of drinking glasses wants to identify and sort out defective glasses in his production. A model for image classification is to be trained and used for this purpose. The database consists of images of intact and defective glasses.</em>” <a href="https://blog.codecentric.de/en/2019/09/7-common-metrics-evaluating-machine-learning-models/" target="_blank">[1]</a> </p><p>The number of pictures of defective glasses is very limited here, so that, with some effort, pictures of about 500 intact and 500 defective glasses will be available for training and testing of the models only after some time – especially because defective glasses occur rather rarely in production. From these 1000 pictures a representative test set is then retained before training.</p><p>How much test data is required for a meaningful evaluation of a machine learning model? Or what does “meaningful” mean in this context? Is 10% to 20% of the data base, in this case 100 to 200 images, sufficient?<br /> In this example, the metric <em>accuracy</em> is selected and after a little training and optimization, the model will achieve a performance of 80% of correct classifications – on a basis of 100 test images.<br /> To estimate how trustworthy this result actually is, you can use standard tools of statistics.</p><h2>Confidence interval</h2><p>Whether an image has been classified correctly by the model can be seen as an experiment with the two possible results <em>success</em> or <em>failure</em>. Testing a model is also a series of similar independent experiments, so that the binomial distribution or its approximation <a href="https://en.wikipedia.org/wiki/De_Moivre–Laplace_theorem" target="_blank">[2]</a>  to the normal distribution can be used to estimate the result.<br /> The extent to which one can now “trust” the determined value can be shown with the help of a confidence interval.<br /> The benefit of a confidence interval is the possibility of quantifying the uncertainty of a sample, for example a test run on 100 images, and the resulting estimate. Estimation because the test data represent only a small part of the possible data set or population, and thus the model has only been tested with a small part of data and not with all data that may ever occur.</p><p>“<em>The confidence interval indicates the range which, with infinite repetition of a random experiment, includes the true location of the parameter with a certain probability (the confidence level).</em>” <a href="https://de.wikipedia.org/wiki/Konfidenzintervall" target="_blank">[3]</a> </p><p>The interval is represented by a lower and an upper limit value and the assumption that the test runs have been repeated quite often on different independent test data sets of the same size. This means, for example, that on average in 95 % of the imaginary test runs the resulting limit values include the determined score.</p><h2>Calculating intervals</h2><p>The limit values can be calculated as follows, for example <a href="https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval" target="_blank">[4]</a> :</p><p><img height="75" width="242" src="https://media.graphassets.com/BbmHrSPEQU6uIgnEjfej" alt="Confidenzinterval"/> </p><p>With <em>p=1/score</em>, <em>n</em> is the number of data and <em>z</em> is a constant that can be read from the standard normal distribution table for the desired “confidence” (confidence level). Common values are, for example:</p><table><tr><td><strong>level</strong></td><td>90 %</td><td>95%</td><td>97%</td><td>99%</td><td>99.5 %</td></tr><tr><td><strong>z</strong></td><td>1.28</td><td>1.64</td><td>1.96</td><td>2.33</td><td>2.58</td></tr></table><p>In case of the 95% confidence level, with 100 test data sets and a measured score of the model of 80%, the interval is 72% to 88%. This range seems to be quite large and probably not accurate enough for some applications.</p><h2>The crux</h2><p>But even when doubling the test data to 200 data sets, the resulting interval: 74% to 86% is not much smaller. The following diagram shows a few more examples of accuracy scores of 80%, 90%, 95% and 99% for the 95% confidence level and for the test data size 100, 200, 1000, 10000. On a basis of 10000 data sets, the range is +-1% and could be acceptable for a score of 80%.<br /> <a href="https://media.graphassets.com/6pPbgPlvS8qI2Po6GjXE"><img loading="lazy" width="250" height="204" src="https://media.graphassets.com/6pPbgPlvS8qI2Po6GjXE" alt="confidence intervals per score" /></a> </p><p>However, for an accuracy of 85% determined on basis of 100 test data, the interval would be 78% to 92%. It therefore also covers a score value of 80%. This suggests that it may be possible to work with less training data and better equip the test data set. Finally, it is possible that if a poorer score is obtained, for example by training on less data, the confidence interval limits will still include the originally better score.<br /> Furthermore, focusing on the last per mil improvement, determined on the basis of a small test set, may not be a goal-oriented endeavour. Or even the effect may occur that after increasing the test data, a model that may not have appeared to be so good before may perform better than the model that was originally preferred due to an insignificantly higher score.<br /> This means that a statement about the performance of the model and differentiation from other models on the basis of a manageable number of test data is only possible to a limited extent.<br /> In general, the larger the sample from which the estimate was drawn, the more precise is the estimate and the smaller and better is the confidence interval.</p><h2>Conclusion</h2><p>Ultimately, the evaluation of a model should be done with a sense of proportion and the size of a test set should be included in the evaluation. Particularly with results that do not differ significantly, the selection of a model based solely on these evaluations may not always be promising. A field test in practice, for example by A/B testing, with several models that cannot be clearly distinguished, can support a decision.</p><h2>References:</h2><p>[1] codecentric blog, <a href="https://blog.codecentric.de/en/2019/09/7-common-metrics-evaluating-machine-learning-models/" target="_blank">Evaluating machine learning models: How to tackle metrics</a> <br /> [2] Wikipedia, <a href="https://en.wikipedia.org/wiki/De_Moivre–Laplace_theorem" target="_blank">De Moivre–Laplace theorem</a> <br /> [3] Wikipedia, <a href="https://de.wikipedia.org/wiki/Konfidenzintervall" target="_blank">Confidence interval (German version)</a> <br /> [4] Wikipedia, <a href="https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval" target="_blank">Binomial proportion confidence interval</a> </p>

Evaluating machine learning models: The issue with test data sets

<p>The quality or usefulness of machine learning models can be evaluated using test data and metrics. However, to what extent? Manually, automated, once, regularly? Manually, the first models as the result of a proof of concept can certainly still be evaluated and compared in a manageable way. If the number of models increases into the dozens or even hundreds, depending on the use case and whether they also have to be constantly retrained, the manual procedure no longer tends to scale.<br /> The preparation of the data, the training of the models and their evaluation can be automated in the form of machine learning pipelines. However, a qualified evaluation of the data or an evaluation of the predictive quality of a model has its pitfalls – especially in automated form.</p><div><a href="https://media.graphassets.com/YBObm2wRSqROEd8qcOjd"><img src="https://media.graphassets.com/YBObm2wRSqROEd8qcOjd" alt="Example of a simple machine learning pipeline" width="1024" height="290" /></a> <p>Example of a simple machine learning pipeline</p></div><p>In classic software development, unit tests, integration tests, end-to-end tests etc. have become established within CI/CD pipelines for quality assurance. However, to create machine learning models, measures that ensure the quality of a model are also necessary. These should accompany the process from the preparation of raw data to the delivery of a model. They can ideally be integrated into the pipeline as well.</p><h2>Quality gate</h2><p>The term ‘quality gate’ originates from project management and describes the introduction of ‘checkpoints’ into the project process. The aim is to divide the project duration into shorter, manageable sections in order to be able to track progress. In this context, verifiable success criteria are to be defined in advance for each gate.<br /> For example, a gate contains a list of goals or quality requirements for the resulting artifacts at the end of a project phase. These must be met before the next stage in the process flow is started. However, checking the status can also lead to the project being aborted – because it becomes transparent that essential characteristics have not been achieved or will very likely not be achieved at all. Stopping a project at an early stage may therefore also save time, resources and money.</p><div><a href="https://media.graphassets.com/oBnm3kOHQMmjSCrYMl2s"><img loading="lazy" src="https://media.graphassets.com/oBnm3kOHQMmjSCrYMl2s" alt="Quality gates in the project process" width="1024" height="368" /></a> <p>Quality gates in the project process</p></div><p>In the machine learning context, quality gates can be integrated as dedicated checks between the individual steps of an automated pipeline. Thus, they can track and monitor the quality of the artifacts in the process. Typical artifacts are the raw and processed data as well as the trained models.</p><h2>Data</h2><p>The quality of the data is the basis for being able to successfully train machine learning models at all. Therefore, the first quality gates are dedicated to the data and they ensure that the training of the models happens on a meaningful data basis. First, the raw data can 
be checked. They must correspond to the previous assumptions/statistics and characteristics, otherwise corrections in the setup of the model and training may become necessary.<br /> In general, the preparation of the raw data is highly individual and may be costly. This means that further test points, which are not shown here, may have to be used between the preparation steps.<br /> In addition, the distribution of the data in the resulting data sets can be tested. A fair and representative distribution of the data as well as a sufficient number of data sets in the sets should be guaranteed. Otherwise, the 
evaluations on possible validation and test sets are only of limited value <a href="https://blog.codecentric.de/en/2020/04/evaluating-machine-learning-models-test-data-sets/">[1]</a> .<br /> There is a tendency that an insufficient data basis does not lead to the high-quality models we aim for. If these 
gates are not passed, an early termination already at the beginning of the pipeline can save time, resources and money, especially if these gates can be introduced with manageable effort.</p><div><a href="https://media.graphassets.com/slpcVQw4STqthyuYHf5M"><img loading="lazy" width="1024" height="307" src="https://media.graphassets.com/slpcVQw4STqthyuYHf5M" alt="Examples of data quality gates within a machine learning pipeline." /></a> <p>Examples of data quality gates</p></div><h2>Metrics</h2><p>In order to evaluate the quality of a model’s predictions in a pipeline, a set of automatically evaluable criteria is mandatory. Ideally, numerical metrics are used for this purpose. These can be evaluated on predictions of the model on the retained test set.<br /> Of course, the possible metrics and threshold values depend on the particular application. For example, in case of a classification it is necessary to find a good tradeoff between coverage and precision and it has to be defined from which prediction certainty a class is considered to be recognized <a href="https://blog.codecentric.de/en/2019/09/7-common-metrics-evaluating-machine-learning-models/">[2]</a> . But once adequate metrics have been selected and the results or threshold values to be achieved have been defined, these criteria can be checked automatically in an initial quality gate for the model.<br /> However, the question arises of course: Is it worth all the effort to introduce complicated machine learning models? Or aren’t there simpler alternatives to meet the requirements?</p><h2>Baselines</h2><p>Rather rudimentary solutions can usually be implemented cheaply and quickly using simpler models. These models can be created by heuristics, simple statistics or even a simple generation of random values and have to be beaten in a test. By comparing them with baseline models, one gets an idea of what performance is easy to achieve. To do this, predictions of the baseline and a candidate model can be generated on the same test set and compared to the selected metrics. How big the difference is to a simpler solution can thus be illustrated.<br /> There should already be a certain performance difference in favor of the more complex model to justify its use. If it is clear at which difference there is a real added value of the ML approach, this can be used as a criterion and thus another gate can be integrated into the process. If the baseline 
is not beaten, further optimization of the data or the training is necessary or even the chosen approach has to be reconsidered.</p><div><a href="https://media.graphassets.com/9J4jBKeXSmKpWzuy8ITG"><img loading="lazy" src="https://media.graphassets.com/9J4jBKeXSmKpWzuy8ITG" alt="Examples for Model Quality Gates within a Machine Learning Pipeline" width="1024" height="426" /></a> <p>Examples of Model Quality Gates</p></div><h2>A/B tests</h2><p>However, the actual performance of the model will probably only become apparent in a real-life situation, for example with the help of A/B tests. <i>The A/B test (also <em>split test</em>) is a test method for evaluating two variants of a system, in which the original version is tested against a slightly modified version.</i> <a href="https://de.wikipedia.org/wiki/A%2FB-Test" target="_blank">[3]</a> . If the infrastructure supports A/B tests, these can be run and provide helpful insights.<br /> For example, correlations between the previously tested offline metrics and the results of the online metrics of the A/B tests might exist. This makes it possible to assess to what extent the offline metrics can predict the performance of the models at all, or which ones should most likely be considered.<br /> What can be done and assessed manually in advance is an A/B test between a first trained model and the baseline.<br /> In addition, if further model approaches are to be tested, the last best model can of course also be compared with a new potentially better model. Thus A/B testing can also be integrated as a quality gate before deployment at the end of the pipeline. However, A/B tests might be time-consuming and therefore not always practical in an automated way.</p><h2>Production</h2><p>One difference, compared to the project management approach, however, is 
that the typical ML process runs in cycles. Ultimately, measuring the quality of a model in the various gates within a machine learning pipeline is just a bet on the future.<br /> Once the model is in production, it is subject to some degeneration, which can vary in degree and speed depending on the domain. This means that models become obsolete over time and may need to be quasi-adapted to new circumstances or data. This can be achieved, for example, by renewing or further training the models, which starts the process all over again.<br /> Quality gates are therefore also to be used during the operation of the models in order to determine whether the model delivers or can continue delivering adequate results in a constantly changing environment.<br /> In the case of a ‘data drift’ the data could have been changed, like the distribution or value ranges of the data or features. Or the patterns that the model 
has learned are no longer valid and are subject to a concept drift. <a href="https://en.wikipedia.org/wiki/Concept_drift" target="_blank">[4]</a> . For example, seasonal effects or, as just happened in times of a pandemic, unexpected effects can influence the prediction quality of models <a href="https://fortune.com/2020/09/23/a-i-algorithms-had-to-change-when-covid-19-changed-consumer-behavior" target="_blank">[5]</a> .<br /> Therefore, even when the model is running, a further gate can regularly check new data and verify that it still matches the assumptions.</p><div><a href="https://media.graphassets.com/RmA8O3V7Snmx5gt3ZdLa"><img loading="lazy" width="1024" height="397" src="https://media.graphassets.com/RmA8O3V7Snmx5gt3ZdLa" alt="Machine Learning Quality Gates Chain" /></a> <p>Machine Learning quality gates chain including monitoring of current model quality</p></div><p>How often a model has to be retrained and which changes have to be made depends on the application and the characteristics of the new conditions. Whether it is worthwhile at all is also to be estimated, since if necessary the costs around new models to train can be not insignificant.<br /> This trade-off between cost and benefit or even criticality of the model is also a gate. But that gate is only opened for the next step, the new training, if the model is ‘bad’ enough.</p><h2>Conclusion</h2><p>As exemplified here, quality gates can be integrated at various points in a pipeline to ensure the quality of the respective artifacts of a sub-process. For this purpose, success criteria that must be met in order to pass a gate must be defined in advance and can be checked automatically.<br /> Stopping a machine learning pipeline early can save time, resources and money. After all, if a gate fails, it is foreseeable that in the 
end a sufficient prediction quality of the model can no longer be guaranteed.<br /> Finally, models must also be monitored in production to detect potential model degeneration at an early stage and respond accordingly.<br /> In addition, a number of other gates and tests can be considered to ensure that the ecosystem around the machine learning approach works in practice. However, this is beyond the scope of this article, but should not go unmentioned here <a href="https://storage.googleapis.com/pub-tools-public-publication-data/pdf/aad9f93b86b7addfea4c419b9100c6cdd26cacea.pdf" target="_blank">[6]</a> .</p><h2>References</h2><p>[1] <a href="https://blog.codecentric.de/en/2020/04/evaluating-machine-learning-models-test-data-sets/">codecentric Blog – Evaluating machine learning models: The issue with test data sets</a> </p><p>[2] <a href="https://blog.codecentric.de/en/2019/09/7-common-metrics-evaluating-machine-learning-models/">codecentric Blog – Evaluating machine learning models: How to tackle metrics</a> </p><p>[3] <a href="https://de.wikipedia.org/wiki/A%2FB-Test">wikipedia – AB-Test</a> </p><p>[4] <a href="https://en.wikipedia.org/wiki/Concept_drift">wikipedia – Concept drift</a> </p><p>[5] <a href="https://fortune.com/2020/09/23/a-i-algorithms-had-to-change-when-covid-19-changed-consumer-behavior">Fortune – A.I. algorithms had to change when COVID-19 changed consumer behavior</a> </p><p>[6] <a href="https://storage.googleapis.com/pub-tools-public-publication-data/pdf/aad9f93b86b7addfea4c419b9100c6cdd26cacea.pdf">Google, Inc. – The ML Test Score: A Rubric for ML Production Readiness and Technical Debt Reduction</a> </p>

Evaluating machine learning models: Establishing quality gates

Consultant Data & AI

<p>Generell sollte man zwar für jedes Problem das passende Werkzeug nutzen. Aber oftmals wird man gezwungen, den Hammer Java zu nutzen, weil der Rest des Hauses mit diesem Hammer gebaut wurde. Eine moderne Lösung dieses Problems ist natürlich die Microservice-Architektur: unabhängige Microservices, die je eine Aufgabe erledigen und in der jeweils am besten passenden Sprache geschrieben sind.</p><p>Aber was tun, wenn der Monolith bereits besteht oder das Projekt nicht groß genug ist, um die hohe Komplexität von Microservices zu rechtfertigen? Nun, für diesen Fall, in dem hohe Kopplung unvermeidbar oder sogar erwünscht ist, möchte ich hier eine Herangehensweise vorstellen. Wir werden lernen, wie wir das Machine-Learning-Ökosystem von Python verwenden, um Reinforcement Learning auf ein in Java implementiertes System anzuwenden. Das in Python trainierte Modell können wir später wieder in Java laden und benutzen. Python wird hier also nur während des Trainings verwendet und nicht im Produktiveinsatz. Der Vorteil ist, dass sich der Data Scientist freut, seine liebsten Werkzeuge verwenden zu können.</p><p>Und da es um Python geht: Welches Beispielproblem würde sich besser eignen als das klassische Spiel <em>Snake</em>? (Die Antwort auf diese rhetorische Frage ist vermutlich: „Eine Anspielung auf Monty Python.“ Aber mir ist kein simples Problem eingefallen, das sich um einen fliegenden Zirkus dreht.)</p><p><a href="https://github.com/surt91/autosnake" target="_blank">Der komplette Quellcode unseres Beispiels ist auf GitHub verfügbar.</a> </p><h2>Snake in Java</h2><p>Unsere Ausgangssituation ist, dass wir ein Java-Programm haben, in dem die Spiellogik von <em>Snake</em> implementiert ist: Es ist immer ein Stück Futter auf dem Spielfeld. Wenn die Schlange Futter erreicht, wird sie länger und neues Futter erscheint. Wenn die Schlange eine der Wände oder sich selbst beißt, ist das Spiel zuende.</p><p>Unser Ziel ist es, ein neuronales Netz zu trainieren, das die Schlange so steuert, dass sie möglichst lang ist, bevor sie einen Fehler macht und das Spiel vorbei ist. Dazu brauchen wir einen Tensor, der den aktuellen Zustand des Spiels darstellt und als Input in das neuronale Netz gefüttert wird, damit es daraus den besten nächsten Schritt vorhersagt. Um dieses Beispiel simpel zu halten, ist unser Tensor nur ein Vektor mit sieben Elementen, die entweder 0 oder 1 sein können: Die ersten vier signalisieren, ob das Futter rechts, links, vor oder hinter der Schlange ist und die nächsten drei Werte signalisieren, ob das Feld links, geradeaus oder rechts von einer Wand oder einem Teil der Schlange besetzt sind.</p><div>

```java
public class SnakeLogic {
    Coordinate head; // position of the snake's head
    Coordinate food; // position of the food
    Move headDirection; // direction in which the head points
 
    public boolean[] trainingState() {
        boolean[] state = new boolean[7];
 
        // get the angle from the head to the food,
        // depending on the direction of movement `headDirection`
        double alpha = angle(head, headDirection, food);
 
        state[0] = isFoodFront(alpha);
        state[1] = isFoodLeft(alpha);
        state[2] = isFoodRight(alpha);
        state[3] = isFoodBack(alpha);
 
        // check if there is danger on these sites
        state[4] = danger(head.left(headDirection));
        state[5] = danger(head.straight(headDirection));
        state[6] = danger(head.right(headDirection));
 
        return state;
    }
 
    // omitted other fields and methods for clarity
    // find them at https://github.com/surt91/autosnake
}
```

</div><p>Einerseits müssen wir diese Methode während des Trainings des neuronales Netzes von Python aus aufrufen können. Andererseits benötigen wir sie auch später im Produktiveinsatz in unserem Java-Programm, um dem fertig trainierten Netz eine Entscheidungsgrundlage zu liefern.</p><h2>Java-Klassen in Python</h2><p>Hier kommt <a href="https://jpype.readthedocs.io/en/latest/userguide.html" target="_blank"><em>JPype</em></a>  ins Spiel! Das Importieren einer Klasse aus Java — ohne dass wir die Java-Seite des Codes anfassen müssten — gelingt einfach durch:</p><div>

```python
import jpype
import jpype.imports
from jpype.types import *
 
# launch the JVM
jpype.startJVM(classpath=['../target/autosnake-1.0-SNAPSHOT.jar'])
 
# import the Java module
from me.schawe.autosnake import SnakeLogic
 
# construct an object of the `SnakeLogic` class ...
width, height = 10, 10
snake_logic = SnakeLogic(width, height)
 
# ... and call a method on it
print(snake_logic.trainingState())
```

</div><p>JPype startet dabei eine eigene JVM im selben Prozess, der auch Python ausführt, und lässt das Python-Programm mit ihr über das Java Native Interface (JNI) kommunizieren. Das kann man sich, etwas vereinfacht, so vorstellen wie das Aufrufen von Funktionen<br /> aus dynamischen Bibliotheken (für eingefleischte Pythonistas ist möglicherweise der Vergleich mit dem Modul <a href="https://docs.python.org/3/library/ctypes.html" target="_blank"><em>ctypes</em></a>  hilfreich). JPype macht dies allerdings sehr komfortabel, indem es die Abbildung von Java- und Python-Klassen aufeinander transparent übernimmt.</p><p>Es sei jedoch noch erwähnt, dass es überraschend viele Projekte mit diesem Ziel und unterschiedlichen Stärken, Schwächen und Anwendungsgebieten gibt. Stellvertretend seien <em>Jython</em> und <em>Py4J</em> erwähnt:</p><p><a href="https://www.jython.org/" target="_blank"><em>Jython</em></a>  führt einen Python-Interpreter direkt in der JVM aus, sodass die gleichen Datenstrukturen effizient von Python und Java aus manipuliert werden können. Allerdings bringt das gleichzeitig Einschränkungen mit sich, was die Nutzung nativer Python-Bibliotheken angeht — da wir <em>numpy</em> und <em>tensorflow</em> nutzen wollen, scheidet diese Option also aus.</p><p><a href="https://www.py4j.org/" target="_blank"><em>Py4J</em></a>  steht eher auf der anderen Seite des Spektrums. Auf der Java-Seite startet es einen Socket, über den es mit der Python-Seite kommuniziert. Der Vorteil ist, dass sich beliebig viele Python-Prozesse mit einem lang laufenden Java-Prozess verbinden können — oder umgekehrt ein Python-Prozess mit vielen JVMs, sogar über das Netzwerk. Der Nachteil ist, dass die Kommunikation über den Socket vergleichsweise langsam ist.</p><h2>Das Training</h2><p>Nun, da wir aus Python Zugriff auf unsere Java-Klassen haben, können wir das Deep-Learning-Framework unserer Wahl — hier Keras — nutzen, um ein Modell zu erstellen und zu trainieren. Da wir in diesem Fall eine Schlange trainieren wollen, möglichst<br /> viele Punkte zu sammeln, werden wir einen <em>Reinforcement-Learning</em>-Ansatz anwenden.</p><p>Reinforcement Learning bedeutet grundsätzlich, dass wir einen Agenten mit einem <em>Environment</em> interagieren lassen, ihn für gute Entscheidungen belohnen und für schlechte bestrafen. Diese Disziplin sorgt häufiger für Aufsehen, beispielsweise<br /> durch das Spielen von <a href="https://arxiv.org/abs/1312.5602" target="_blank">klassischen Atari-Spielen</a>  oder <a href="https://de.wikipedia.org/wiki/AlphaZero" target="_blank">Go</a> .</p><p>Für unseren Fall bietet es sich an, ein Trainings-Environment zu schreiben, das sich eng an den <a href="https://gym.openai.com/docs/" target="_blank"><em>Gym</em>s von OpenAI</a>  orientiert, da diese für Reinforcement-Learning einen Quasi-Standard darstellen.</p><p>Dafür brauchen wir zunächst eine Methode <code>step</code>, die eine Aktion <code>action</code> entgegennimmt, einen Zeitschritt simuliert und das Ergebnis der Aktion zurückgibt. Die <code>action</code> ist dabei der Output des neuronalen Netzes und bestimmt, ob die Schlange sich nach links oder rechts dreht oder sich weiter geradeaus bewegt. Das zurückgegebene Ergebnis besteht aus</p><ol><li><code>state</code>, dem neuen Zustand (unser siebener Vektor),</li><li><code>reward</code>, der Bewertung der Aktion: 1 wenn die Schlange Futter gefressen hat, -1 wenn die Schlange sich selbst oder eine Wand gebissen hat und sonst 0. Und</li><li><code>done</code>, ob die Partie vorbei ist, also ob die Schlange sich selbst oder eine Wand gebissen hat. Sowie</li><li>einem Dictionary mit Debugging-Informationen, das wir in unserem Fall einfach leer lassen.</li></ol><p>Außerdem benötigen wir eine Methode <code>reset</code>, um eine neue Partie zu starten, die ebenfalls den neuen Zustand zurückgibt.</p><p>Beide Methoden können wir dank unserer existierenden Java-Klasse sehr einfach schreiben:</p><div>

```python
import jpype
import jpype.imports
from jpype.types import *
 
# Launch the JVM
jpype.startJVM(classpath=['../target/autosnake-1.0-SNAPSHOT.jar'])
 
# import the Java module
from me.schawe.autosnake import SnakeLogic
 
 
class Snake:
    def __init__(self):
        width, height = 10, 10
        # `snakeLogic` is a Java object, such that we can call
        # all its methods. This is also the reason why we
        # name it in camelCase instead of the snake_case
        # convention of Python.
        self.snakeLogic = SnakeLogic(width, height)
 
    def reset(self):
        self.snakeLogic.reset()
 
        return self.snakeLogic.trainingState()
 
    def step(self, action):
        self.snakeLogic.turnRelative(action)
        self.snakeLogic.update()
 
        state = self.snakeLogic.trainingState()
 
        done = False
        reward = 0
        if self.snakeLogic.isGameOver():
            reward = -1
            done = True
        elif self.snakeLogic.isEating():
            reward = 1
 
        return state, reward, done, {}
```

</div><p>Diese Trainingsumgebung können wir nun mit minimalem Aufwand in das <a href="https://keras.io/examples/rl/actor_critic_cartpole/" target="_blank">erste Beispiel aus der Keras-Dokumentation</a>  für Reinforcement Learning einbauen und das leicht angepasste Skript direkt nutzen, um mit dem Training zu beginnen:</p><figure> <img loading="lazy" width="200" height="200" src="https://media.graphassets.com/sOvVWDgxTkjdHl0SgVR9" alt="Beginn des Trainings" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/VBcx4FbTR66jP8zWwi5L" alt="Nach 200 gespielten Spielen" /><br /> <img loading="lazy" width="200" height="200" src="https://media.graphassets.com/XvrD3ETtQ4u73y05pOhM" alt="Nach 400 gespielten Spielen" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/U5o6PoiTQCoDEep0RZXU" alt="Nach 3000 gespielten Spielen" /><figcaption>Spätestens seit <em>Rocky</em> wissen wir, dass ein Training nur mit eineer Trainings-Montage gut ist.</figcaption></figure><p>Die Schlange lernt tatsächlich dazu! Innerhalb weniger Minuten läuft sie zielstrebig auf das Futter zu und weicht Wänden aus — allerdings fängt sie sich gerne selbst. Für unsere Zwecke soll dieses Verhalten aber vorerst ausreichen.</p><h2>Modell in Java laden</h2><p>Um den Kreis zu schließen, laden wir unser trainiertes Modell mit <em>deeplearning4j</em> in Java …</p><div>

```java
// https://deeplearning4j.konduit.ai/deeplearning4j/how-to-guides/keras-import
public class Autopilot {
    ComputationGraph model;
 
    public Autopilot(String pathToModel) {
        try {
            model = KerasModelImport.importKerasModelAndWeights(pathToModel, false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    // infer the next move from the given state
    public int nextMove(boolean[] state) {
        INDArray input = Nd4j.create(state).reshape(1, state.length);
        INDArray output = model.output(input)[0];
 
        int action = output.ravel().argMax().getInt(0);
 
        return action;
    }
}
```

</div><p>… wo wir die selben Methoden aufrufen, die wir während des Training genutzt haben, um die Schlange zu steuern.</p><div>

```java
public class SnakeLogic {
    Autopilot autopilot = new Autopilot("path/to/model.h5");
 
    public void update() {
        int action = autopilot.nextMove(trainingState());
        turnRelative(action);
 
        // rest of the update omitted
    }
 
    // further methods omitted
}
```

</div><h2>Fazit</h2><p>Unter dem Strich ist es also überraschend einfach Java und Python gemeinsam zu nutzen, was vor allem zur Prototypen-Entwicklung sehr effizient sein kann.</p><p>Und es muss nicht direkt Deep Learning sein. Durch die sehr einfache Anwendbarkeit gibt es sicherlich auch Potential, diesen Ansatz zu wählen, um etwas explorative Datenanalyse auf der Datenbank unter Verwendung der gesamten Geschäftslogik in einem iPython Notebook zu betreiben.</p><p>Was unser Anwendungsbeispiel angeht: Dafür, dass wir keinerlei Gedanken in das Modell gesteckt haben, ist das Ergebnis überraschend gut. Für bessere Ergebnisse müsste man vermutlich das ganze Spielfeld in das neuronale Netz füttern und wir müssten uns etwas mehr Gedanken über das Modell machen. Eine kurze Google-Recherche zeigt, dass es anscheinend Modelle gibt, die ein perfektes Spiel Snake spielen können, sodass jedes einzelne Feld belegt ist. Für Snake ist es möglicherweise jedoch sinnvoller, das neuronale Netz zwischen den Ohren zu verwenden, um eine perfekte Strategie zu entwickeln. Zum Beispiel wird es immer ein perfektes Spiel, wenn die Schlange sich immer auf einem Hamilton-Pfad (ein Pfad, der alle Gitterplätze, ausgenommen die von der Schlange belegten, genau einmal besucht) zwischen Kopf und Schwanzende bewegt. Wie man effizient diese Hamilton-Pfade findet, ist dem Leser als Übung überlassen.</p>

Wie man Java-Klassen in Python benutzt

<p>There is an old truism: “Use the right tool for the job.” However, in building software, we are often forced to nail in screws, just because the rest of the application was built with the figurative hammer Java. Of course, one of the preferred solutions to this problem is <em>microservices</em>, which each handle one task and can be written in the most suitable language.</p><p>But what to do if the monolith already exists, or the project is not large enough to justify the increased complexity of microservices? Well, in this case, if tight coupling is unavoidable or even preferred, we can use the approach I am going to show in this blog post. We will learn how to use the machine learning ecosystem of Python to apply <em>reinforcement learning</em> to a system implemented in Java. After training, we can load the model into Java and use it. Therefore, we only use Python during the training and not in production. What’s best about this approach is that it ensures a happy data scientist who can use the right tools for the job.</p><p>And since this is about Python: What would be a better toy example than the classic game <em>Snake</em>? (The answer to this rhetorical question is, of course: “Some reference to Monty Python.” But I really could not think of a simple problem about a flying circus.)</p><p><a href="https://github.com/surt91/autosnake" target="_blank">The complete source code of our example is available on GitHub.</a> </p><h2>Snake in Java</h2><p>We are starting with a Java program implementing the game logic of Snake: there is always a piece of food on the field. Whenever the snake reaches the food, it grows and new food appears. If the snake bites itself or a wall, the game ends.</p><p>Our objective is to train a neural net to steer the snake such that the snake eats as much food as possible before it makes a mistake and the game ends. First, we need a tensor which represents the current state of the game. It acts as the input of our neural net, such that the net can use it to predict the best next step to take. To keep this example simple, our tensor is just a vector of seven elements, which can either be 1 or 0: the first four indicate if the food is right, left, in front of or behind the snake and the next three entries signal if the fields left, in front of and right of the snake’s head are blocked by a wall or the tail of the snake.</p><div>

```java
public class SnakeLogic {
    Coordinate head; // position of the snake's head
    Coordinate food; // position of the food
    Move headDirection; // direction in which the head points
 
    public boolean[] trainingState() {
        boolean[] state = new boolean[7];
 
        // get the angle from the head to the food,
        // depending on the direction of movement `headDirection`
        double alpha = angle(head, headDirection, food);
 
        state[0] = isFoodFront(alpha);
        state[1] = isFoodLeft(alpha);
        state[2] = isFoodRight(alpha);
        state[3] = isFoodBack(alpha);
 
        // check if there is danger on these sites
        state[4] = danger(head.left(headDirection));
        state[5] = danger(head.straight(headDirection));
        state[6] = danger(head.right(headDirection));
 
        return state;
    }
 
    // omitted other fields and methods for clarity
    // find them at https://github.com/surt91/autosnake
}
```

</div><p>We will need this method on two occasions. First, during the training, where we will call it directly from Python. And later in production, where we will call it from our Java program to give the trained net a basis for making a decision.</p><h2>Java classes in Python</h2><p>Enter <a href="https://jpype.readthedocs.io/en/latest/userguide.html" target="_blank"><em>JPype</em></a> ! The import of a Java class — without any changes to the Java sources — can be accomplished simply with the following code:</p><div>

```python
import jpype
import jpype.imports
from jpype.types import *
 
# launch the JVM
jpype.startJVM(classpath=['../target/autosnake-1.0-SNAPSHOT.jar'])
 
# import the Java module
from me.schawe.autosnake import SnakeLogic
 
# construct an object of the `SnakeLogic` class ...
width, height = 10, 10
snake_logic = SnakeLogic(width, height)
 
# ... and call a method on it
print(snake_logic.trainingState())
```

</div><p>JPype starts a JVM in the same process as the Python interpreter and lets them communicate using the Java Native Interface (JNI). One can think about it, in a simplified way, like calling functions from dynamic libraries (experienced Pythonistas may find a comparison to the module <a href="https://docs.python.org/3/library/ctypes.html" target="_blank"><em>ctypes</em></a>  helpful.) But JPype does this in a very comfortable way and automatically maps Java classes on Python classes.</p><p>It should also be noted that there is a surprising number of projects with this objective, each with their own strengths and weaknesses. As representatives, we will quickly look at <em>Jython</em> and <em>Py4J</em>.</p><p><a href="https://www.jython.org/" target="_blank"><em>Jython</em></a>  executes a Python Interpreter directly in the JVM, such that Python and Java can very efficiently use the same data structures. But this comes with a few drawbacks for the usage of native Python libraries — since we will use <em>numpy</em> and <em>tensorflow</em>, this is not an option for us.</p><p><a href="https://www.py4j.org/" target="_blank"><em>Py4J</em></a>  is on the opposite side of the spectrum. It starts a socket in the Java code, over which it can communicate with Python programs. The advantage is that an arbitrary number of Python processes can connect to a long-running Java process — or the other way around, one Python process can connect to many JVMs, even over the network. The downside is a larger overhead of the socket communication.</p><h2>The training</h2><p>Now that we can access our Java classes, we can use the deep learning framework of our choice — in our case, Keras — to create and train a model. Since we want to train a snake to collect the maximum amount of food, we choose a reinforcement learning approach.</p><p>In reinforcement learning an agent interacts with an environment and is rewarded for good decisions and punished for bad decisions. In the past, this discipline has drawn quite some media attention for playing <a href="https://arxiv.org/abs/1312.5602" target="_blank">classic Atari games</a>  or <a href="https://en.wikipedia.org/wiki/AlphaZero" target="_blank">Go</a> .</p><p>For our application, it makes sense to write a class that adheres closely to the <a href="https://gym.openai.com/docs/" target="_blank">OpenAI <em>Gym</em>s</a> , since they are a de facto standard for reinforcement learning.</p><p>Therefore we need a method <code>step</code>, which takes an <code>action</code>, simulates a time step, and returns the result of the action. The <code>action</code> is the output of the neural net and suggests whether the snake should turn left or right or not at all. The returned result consists of</p><ol><li><code>state</code>, the new state (our vector with seven elements),</li><li><code>reward</code> our valuation of the action: 1 if the snake could eat food in this step, -1 if the snake bit itself or a wall and else 0. And</li><li><code>done</code>, an indicator whether the round is finished, i.e. if the snake bit itself or a wall. Also</li><li>a dictionary with debugging information, which we just leave empty.</li></ol><p>Further, we need a method <code>reset</code> to start a new round. It should also return the new state.</p><p>Both methods are easy to write thanks to our already existing Java classes:</p><div>

```python
import jpype
import jpype.imports
from jpype.types import *
 
# Launch the JVM
jpype.startJVM(classpath=['../target/autosnake-1.0-SNAPSHOT.jar'])
 
# import the Java module
from me.schawe.autosnake import SnakeLogic
 
 
class Snake:
    def __init__(self):
        width, height = 10, 10
        # `snakeLogic` is a Java object, such that we can call
        # all its methods. This is also the reason why we
        # name it in camelCase instead of the snake_case
        # convention of Python.
        self.snakeLogic = SnakeLogic(width, height)
 
    def reset(self):
        self.snakeLogic.reset()
 
        return self.snakeLogic.trainingState()
 
    def step(self, action):
        self.snakeLogic.turnRelative(action)
        self.snakeLogic.update()
 
        state = self.snakeLogic.trainingState()
 
        done = False
        reward = 0
        if self.snakeLogic.isGameOver():
            reward = -1
            done = True
        elif self.snakeLogic.isEating():
            reward = 1
 
        return state, reward, done, {}
```

</div><p>Now, we can easily insert this training environment into the <a href="https://keras.io/examples/rl/actor_critic_cartpole/" target="_blank">first example for reinforcement learning of the Keras documentation</a>  and directly use it to start the training:</p><figure><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/sOvVWDgxTkjdHl0SgVR9" alt="Begin of the training" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/VBcx4FbTR66jP8zWwi5L" alt="After 200 played Games" /><br /> <img loading="lazy" width="200" height="200" src="https://media.graphassets.com/XvrD3ETtQ4u73y05pOhM" alt="After 400 played Games" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/U5o6PoiTQCoDEep0RZXU" alt="After 3000 played Games" /><figcaption>Since <em>Rocky</em> it is clear that a training montage is necessary for success.</figcaption></figure><p>The snake learns! Within a few minutes, it begins to directly move towards the food and avoids the walls — but it still tends to trap itself quickly. For our purposes this should suffice for now.</p><h2>Load the model in Java</h2><p>Now we come full circle and load the trained model into Java using <em>deeplearning4j</em> …</p><div>

```java
// https://deeplearning4j.konduit.ai/deeplearning4j/how-to-guides/keras-import
public class Autopilot {
    ComputationGraph model;
 
    public Autopilot(String pathToModel) {
        try {
            model = KerasModelImport.importKerasModelAndWeights(pathToModel, false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    // infer the next move from the given state
    public int nextMove(boolean[] state) {
        INDArray input = Nd4j.create(state).reshape(1, state.length);
        INDArray output = model.output(input)[0];
 
        int action = output.ravel().argMax().getInt(0);
 
        return action;
    }
}
```

</div><p>… where we call the same methods used during training to steer the snake.</p><div>

```java
public class SnakeLogic {
    Autopilot autopilot = new Autopilot("path/to/model.h5");
 
    public void update() {
        int action = autopilot.nextMove(trainingState());
        turnRelative(action);
 
        // rest of the update omitted
    }
 
    // further methods omitted
}
```

</div><h2>Conclusion</h2><p>It is surprisingly easy to make Java and Python work hand in hand, which can be especially valuable when developing prototypes.</p><p>What’s more, it does not have to be deep learning. Since the connection between Java and Python is so easy to use, there certainly is potential to apply this approach to facilitate explorative data analysis on a database using the full business logic in an iPython notebook.</p><p>Regarding our toy example: Given that we did not spend a single thought on the model, the result is surprisingly good. For better results, one probably would have to use the full field as input and think a bit more about the model. Quick googling shows that<br /> apparently there are models which can play a perfect game of Snake, such that the snake occupies every single site. For Snake, it might be more sensible to use the neural net between one’s ears to think of a perfect strategy. For example, we can ensure a<br /> perfect game if the snake always moves on a Hamilton path between its head and the tip of its tail (i.e. a path which visits all sites except those occupied by the snake). How to find Hamilton paths efficiently will be left to the reader as an exercise.</p>

How to use Java classes in Python

IT-Consultant

Senior Industrial Solutions Developer and Consultant

<div><h2>Summary of Part 1</h2><p>In the <a href="https://blog.codecentric.de/en/2018/08/understanding-iot-part-1/">first part</a>  of this blog post we postulated that an IoT device in general is an abstract real-world interface. Subsequently, a general definition of the concept of innovation was elaborated and we found that three aspects in particular are decisive for whether a novelty will prevail over time: maturity, accessibility and need, the latter meaning the size of the problem space that can be solved by the innovation. This thesis statement was further illustrated using the example of the so-called “Industrial Revolutions.” The first part was then concluded with the observation that humanity has today reached a point of technological advancement where at least two of the three characteristics that qualify a novelty as an innovation – maturity and accessibility – are fulfilled for the IoT.</p><h2>The need for IoT</h2><p>The need for IoT is somewhat complicated to explain as it does not directly derive from e.g. customer demand. Rather, it is a direct result of the technological process up to this point. In order to better understand this concept, it makes sense to once again take look at the aforementioned “Industrial Revolutions”. As discussed in the first part of the post, each of the Industrial Revolutions had a unique, distinguishing characteristic at its core. For the first one, this was <em>mechanization</em>. The second one was <em>electrification</em>, followed by <em>digitization</em> for the final one. What was left out in this discussion, however, was what kind of problem space (on a meta-level) they actually addressed. This will be elaborated in the following.</p><p>The first two revolutions mainly influenced the “blue collar” domain as they solved simple (<em>mechanization</em>) and complicated (<em>electrification</em>) mechanical (as in “touchable”) problems. <em>Digitization</em>, on the other hand, primarily affected the “white collar” sector. Still, the problems it helped to solve fall in the same categories – simple and complicated. As a result, humanity became rather effective at automating repetitive tasks and those that are defined by intrinsic rules or coherencies after assimilating these developments across the board.</p><p>So, assuming that this development will continue, where does this lead to now and in the future? So far, humankind has managed to find solutions for simple and complicated tasks both in the mechanical and in the digital domain. With these gone and based on a problem-driven motivation, the next logical step from a systems theory point of view would obviously be to start opening up the area of complex problems.</p><p>Now there is a significant distinction between the nature of simple vs. complicated and complex problems. While the former are characterized by an inherent linearity and can therefore be handled very effectively with rule-based cause-and-effect approaches, this is not persistently true for the latter. Complex systems are non-linear at their core. They require a test-driven methodology with short feedback cycles (comparable to an agile workflow, which is, in the end, nothing more than an approach to address exactly this issue). Yet, to be able to generate feedback for a test, one needs metrics and especially measuring data. The better the data basis, the higher the quality of the conclusions that can be drawn from it. This means as humanity moves up in the complexity scale, the need for data grows exponentially.</p><p>This, in consequence, requires an equally growing number of data sources, be it virtually as part of software systems (e.g. to be able to analyze customer behavior in an online shop) or in the form of real-world interfaces for physical processes. So from this point of view, the need for IoT derives directly from humankind’s problem-driven endeavor to conquer the domain of the complex.</p><p>Most interestingly, this up until this point rather abstract reasoning directly matches current observations from the free market. At the very latest the rise of companies such as Amazon demonstrated that there is currently a shift taking place from an <em>industrial</em> to a <em>post-industrial</em> market. Along with that came a paradigm shift away from <em>cost optimization</em> towards <em>customer orientation</em>, meaning it is no longer sufficient to simply minimize production costs. Instead, what became most important is to adapt to the customer’s wishes and needs as fast as possible. Therefore, one needs feedback, ways to <em>measure</em> e.g. user behavior and habits. Again, this development implies an increase in data sources. So here too, the need for IoT is justified by the shift of the market from a complicated (<em>industrial</em>) to a complex state (<em>post-industrial</em>).<br /> The same trend can be observed in the manufacturing industry, where an increase in connectivity and data generation as well as monitoring along the value creation flow and even beyond that to the end customer lead to new levels of automation, flexibility, and customizability as it allows for situation-oriented and forward-looking acting.</p><p>So, to summarize this post up to this point and to answer the questions formulated at the beginning of the first part: is IoT of (long-term) relevance? Definitely yes. Is the topic currently overhyped? Maybe. Is it the next multi-billion dollar market? Probably (at least for some industries). The last section of this post is going to focus on possible future developments in this domain.</p><h2>Future developments and constitutive technologies</h2><p>To complete this post after analyzing past and present developments in the previous sections, we will look at possible future trends in the field of IoT. This discussion should, however, be treated with caution as the subject of the former is of time-variant nature, meaning it is an evolutionary <em>process</em> that is highly intertwined with many other domains instead of a rigid, encapsulated state. This means even the best prediction is but an extrapolation of a complex system and thus, by definition, never completely true.</p><p>Now, when trying to extrapolate the future development of a process, there are two dimensions one has to consider: vertical and horizontal. The former describes the internal evolution of an individual subject while the latter focusses more on the synergies between different topics and how they influence each other’s development. Of course, both dimensions are closely related to each other as they are ultimately two points of view on the same matter, but for reasoning purposes this separation can be quite helpful in terms of clarity.</p><p>As for the vertical development, the rough path is relatively clear. As discussed before, it’s the shift from the complicated to the complex domain that causes the need for IoT as a symptom of the exploding demand for data. Since this development is currently still at the very beginning and humanity hasn’t even exploited more than a small fraction of the problem space that can be addressed by this, it is highly likely that the number of real-world interfaces will continue to increase exponentially in the near future.</p><p>In the long run, this development inevitably leads to what is known as <em>ubiquitous computing</em> in an attempt to virtually map the entire complexity of the physically domain (the same as it is being done for simple and complex tasks today). That means IT will be almost everywhere in the future but more and more invisible at the same time as it will seamlessly integrate into our daily lives as part of the accustomed service landscape. Conversely, this implies that real-world interfaces will have a growing influence on how software will be developed, just like IT will become more and more relevant for (non-software) engineering processes. In the long run, both historically separated domains will probably start to merge to a certain degree (comparable to the traditional electrician and mechanic), e.g. leading to the rise of so called Cyber-Physical Systems (CPS). So in a sense one could even label IoT a “domain breaker”. The long-term result of this development will probably be a much more wholistic, problem-focussed way of programming than it is common today.</p><p>Even so, the role of IoT will most likely not be the front-facing part. As stated before, it is a topic that tackles the foundation, the data aggregation and (real world) interfacing layer, and as such is more likely to take the role of a catalyst for continuative technologies like e.g. AI.</p><p>This directly leads to the horizontal dimension. There are several current technologies that can be said to be <em>building upon</em> IoT and that are in high synergy with this subject. An overview of some especially noteworthy topics in this respect shall be given in the following:<br />  </p><ul><li> <strong>Contextual Computing</strong>: The term “Contextual Computing” describes an environment that adapts its behavior depending on who is present or using it. This strongly relates to the ongoing trend of service-orientation as this adds another level of individuality to the user experience. Even though this field is still quite new, it’s already common practice in software development – especially in web and mobile development – to have certain features that adapt based on the person accessing the resource. This is usually closely connected to machine learning and behavioral analysis. An example would be the customized buy recommendations on e.g. Amazon or eBay.<p>Recently, however, this trend has also been expanding more and more into the <em>real world domain</em>. Automobile seats that automatically switch configurations based on which person is driving or coffee machines that learn and recognize the user’s preferences are just some of the more common examples. In this context the second dimension of Contextual Computing, devices that adapt to their environment (instead of the other way around), becomes interesting as well. In combination with the ongoing development towards ubiquitous computing, this trend allows for an expansion of service-orientation into the physical world.</p></li><li> <strong>Human-Centered Interfaces (HCI)</strong>: Recent developments have proven once again that there are many use cases where textual input is unarguably not the most suitable form of interaction. Instead, new forms of human-machine interfaces (HMIs) with the user at their center are being researched. A current example would be the voice interface, e.g. to control smart home devices or to create reminders, etc. – in short, minor tasks in which it relieves the user if they do not require his or her active focus in claiming.<br /> At the moment, this field is undergoing a major development. A good summary of the current state of this technological field and an interesting perspective on the future can e.g. be found under <a href="https://waitbutwhy.com/2017/04/neuralink.html#part3" target="_blank">[1]</a>  (strong focus on Brain Machine Interfaces [BMIs]). In any case, IoT devices are the foundation for this development as they represent the interface used to interact with the environment, both sensors and actors.</li><li> <strong>Artificial Intelligence (AI)</strong>: This one might not be that surprising for anyone who follows the current trends in the software world, but nevertheless, this might very well be the most important horizontal development in terms of synergies with the continuous increase of IoT devices. In the end, both AI (resp. Machine Learning [ML]) and ubiquitous computing are targeting the same goal. Both aim to help conquer the complex domain – IoT on the database and AI on the computing/logic side. Thus the harmony between these topics is, to a certain degree, almost immanent.<p>The problem with only IoT is that it provides access to a HUGE amount of data, but data itself is worthless if no information is extracted from it. As it is not possible to process quantities of this order of magnitude by hand, automated algorithms are used. Yet, common algorithms for data processing reach their limits when it comes to complex factual contexts as it is an immanent characteristic of complexity that it can’t be grasped on the basis of rules (so, the other way round, if “normal” algorithms were sufficient, the problem wouldn’t be of complex nature). In this regard, however, AI algorithms shine because they are capable of learning and recognizing complex immanent connections in the data basis. On the other hand, this kind of algorithms synergizes well with IoT as with increasing problem complexity and with a rising number of input dimensions there is an exponentially growing need for data to train the model.</p><p>So, to sum it up, there are multiple areas in which both fields can greatly benefit from each other. Two great examples that demonstrate the potential of this are AWS Greengrass (cf. <a href="https://aws.amazon.com/de/greengrass/" target="_blank">[2]</a> ) and Azure IoT Edge (cf. <a href="https://azure.microsoft.com/en-us/services/iot-edge/" target="_blank">[3]</a> ), which both beautifully combine the concepts of IoT and AI to enable automated monitoring of live data streams.</p></li></ul><h2>Summary</h2><p>Although IoT is currently a slightly hyped topic and there seem to be some misunderstandings regarding its immanent nature, it is yet a subject of prevailing relevance. As an element in the process of technological evolution, it fulfills the characteristics of an innovation. Furthermore, a strong need for this subject can directly be derived from the currently ongoing fundamental shift from the complicated to the complex domain, not only in the free market, but also in production, logistics, etc. Thus it is highly probable that IoT will drastically influence the (real world) interfacing and data aggregation layer serving as a foundation for many continuative topics such as AI, eventually leading to ubiquitous computing as well as to a boost of technologies synergistically related to this domain. However, which areas will be affected to what degree exactly will show over time.</p></div><p><a href="https://blog.codecentric.de/en/2018/08/understanding-iot-part-1/">Understanding IoT (Part 1)</a> </p>

Understanding IoT (Part 2)

<div><h2>Introduction</h2><p>The Internet of Things, short “IoT”, belongs, without a doubt, to the trend topics (not to say <em>hype</em> topics) of the present time. Who doesn’t know the studies predicting the explosion of internet-connected devices in the near future (cf. e.g. <a href="https://www.forbes.com/sites/michaelkanellos/2016/03/03/152000-smart-devices-every-minute-in-2025-idc-outlines-the-future-of-smart-things/" target="_blank">[1]</a>  or <a href="http://www.businessinsider.com/former-cisco-ceo-500-billion-connected-devices-by-2025-2015-11" target="_blank">[2]</a> )?<br /> But is there really something to these statements? Is there a new multi-billion dollar market just waiting around the corner? Or is it just another overhyped buzzword topic of which there are currently so many?</p><p>This question and others will be addressed in this post. In the first step, we will establish a general definition of the term IoT. Then, after defining the concept of innovation, the current development regarding IoT is placed in its historical context. From this we will deduce why the Internet of Things is actually an innovation. Afterwards, the different aspects belonging to the field “IoT” are elaborated and the problems addressed by them are discussed. We will conclude this post with an outlook on potential future developments in this domain.</p><h2>General description of IoT</h2><p>In the most general sense, IoT describes the basic (bidirectional) interaction between a connected real world interface and an arbitrary logical entity — e.g. a component of a traditional IT infrastructure — or another real-world interface.<br /> It’s a common misunderstanding that the term IoT is restricted to hardware devices with low computing power like e.g. microcontroller units (MCUs) or single-board computers like the Raspberry Pi. Although this impression can easily be implied by their strong dissemination in high-profile maker projects (e.g. through blog posts, social media, etc.), they still only make up for a fraction of the entirety, comparable to how deep learning is a part of AI yet AI is not solely deep learning.</p><p>Instead, IoT in its core comprises the whole field layer (from the German term “Feldebene”; the entirety of devices interacting with the (real world) environment). Besides the aforementioned low-power devices (incl. traditional connected sensors/actuators), this furthermore includes e.g. voice assistants such as Amazon Echo, household objects such as a “smart” (whatever that may mean) freezer or – in a more industrial context – even connected programmable logic controllers (PLCs) and (partly) robots.</p><p>This description may be interpreted as a general definition of the term IoT. In order to be able to answer the questions formulated beforehand, however, this alone is not sufficient. Therefore it is necessary to dive deeper into the topic and to look at the underlying concepts.</p><h2>The innovation cycle</h2><p>To understand the concepts underlying IoT, it is first necessary to understand the evolutionary technical process preceding it. For this, a general definition of the concept of innovation is required in the first place.</p><p>In contradiction to the generally widespread interpretation, innovation does not mean to create something completely new from the ground up. A historical view on humankind’s great technological achievements shows that it is rather a process of recombining existing knowledge and/or resources with slight modifications to fit an existing problem <em>at the right time</em>. The latter is an important, often neglected factor, as it is paramount for predicting if a novelty is going to disrupt existing structures or if it is, figuaratively speaking, going to sink into obscurity as the world isn’t ready for it (yet). In general, there are several implications that have to be met (at least partly) for an innovation to develop clout, amongst others maturity of the technological field, accessibility of the technology itself and the size of the sphere of influence of the problem that can be solved by this novelty. The first two mainly influence the general prevalence resp. acceptance of the innovation, the latter is critical for the disruptiveness of the respective development.</p><p>A good example to further illustrate this coherence is provided in form of the so-called “Industrial Revolutions”. If you look at the past developments since the mid-18th century when the first of these shifts took place, one can find the same repeating pattern whenever a disrupting technological breakthrough was achieved.</p><p>It always starts with technological advancement in a (new) field beyond the industrial mainstream. The domain stays very much self-contained until it advances past a certain level, usually the moment when it becomes ready for usage in an industrial context (maturity) or when its complexity deceeds a certain level so that the usage doesn’t require specific expert knowledge anymore (accessibility). At this point, other industries start to become aware of the existence of the novelty and start to examine their own field for problems that could be solved by this or for new business models that become possible. In that case, the new branch is either assimilated or merged into the value chain. And if the resonance across the field as well as the impact this has on the further development is high enough (problem’s sphere of influence), one starts to speak of a “revolution”. As a result, many new fields and possibilities open up and a period of enormous technological advancement begins. This is mostly accompanied by a social disruption as a reaction to the novelties and their influences on daily life.<br /> After the era of fast development comes a technological recession when the novelties start to settle down. This could also be called the <em>integration phase</em> because this is the time when all the initial works and concepts from before are fine-tuned and integrated across the board. It’s usually this stage when new ideas and concepts, enabled and catalyzed by the advancement from the previous revolution, begin to emerge in the shadows. The cycle starts anew.</p><p>This innovation cycle can be observed at many points throughout history. It began with the <em>mechanization</em> that enabled industrial use of steam machines in the mid- to late-18th century. As a consequence, especially the metal industry advanced enormously which then again facilitated the uprising of the railroad and electrical industries that lived an existence in the shadows (resp. in theory and R&D) up until then. This led to the second revolution in the late 19th century which brought upon the beginnings of what is know as <em>globalization</em> today as well as the <em>electrification</em> of social and productive organization. And lastly, there’s the most “recent” third industrial revolution in the mid 1900s that marked the shift from mechanical and analogue to digital electronics and that was a (more or less) direct result of the uprising of the semiconductor industry and thus of the preceding revolution. The most fitting description for this time would probably the “era of <em>digitization</em> and <em>automation</em>“.</p><h2>IoT & Innovation</h2><p>To summarize the above, so far a general definition of the concept of innovation has been established, the differences between normal and disruptive innovations have been analyzed and some examples in the form of the so called “Industrial Revolutions” have been discussed.</p><p>Looking at the outcome of the last revolution, what one will find is that there were basically two major sectors afterwards that overshadowed the rest and that determined the direction of further technological progress: the digital and the (consumer) electronics industry. Yet, it should be noted that the success of the latter was at least partly chained to that of the former as it provided the interface to the content that was produced by the software developers. So it’s probably okay to say that it was mainly the IT industry that was the driving force in the late 20th century.</p><p>For quite some time, the software branch developed on its own. The ambitions to fully exploit the potential of the internet predominated pretty much everything else. Additionally, hardware was rather expensive in the beginning, so it didn’t seem very profitable to make use of it any more than absolutely necessary. The result were effects like the dot-com bubble in the early 2000s as well as a complete redistribution of power among the big players with the uprising of companies like Yahoo, Google or MySpace and later Facebook, Amazon & co.<br /> But at the same time, the electronics industry didn’t just sit still. While the software branch fought over the supremacy over the internet, the exponentially increasing demand for computers, smartphones, etc. led to a constant advancement in this sector. Quantities increased while size and prize of the components dropped dramatically over the years. Figuratively speaking: The same (or even more) computing power that cost thousands of dollars about two or three decades ago is now available for under 10$ in form of e.g. an Arduino or a Raspberry Pi Zero. At the same time, connectivity in general increased massively as well as a direct necessity for the users to be able to access the content developed by the emerging software industry.</p><p>Now, with regard to the above definition of the term innovation, one can say that today humankind has arrived at a point in development where the requirements of maturity and accessibility are definitively satisfied. Computing power has become generally available (e.g. in the cloud), hardware costs have declined massively and a huge software ecosystem with prefabricated solutions for almost any common use case has been established in the meantime. By combining these individual pieces, it becomes possible to deploy many of the technological advancements from the software industry that humanity has become affiliated with over the last ~30 years from private computers and smartphones, etc. to devices, machines, buildings, everything and connect them among each other or with the internet. This alone already qualifies this newly emerging development, also known as IoT, as an innovation with a high probability of prevailability.</p><p>Even so, what’s left to discuss is the problem space that is solved by this development resp. the need that is covered by it as this is significant for the clout and thus the disruptiveness of an innovation. This is going to be the topic of the <a href="https://blog.codecentric.de/en/2018/08/understanding-iot-part-2/">second part</a> .</p></div><p><a href="https://blog.codecentric.de/en/2018/08/understanding-iot-part-2/">Understanding IoT (Part 2)</a> </p>

Understanding IoT (Part 1)

I(o)T Consultant | Data & ML stuff

IT Consultant

Consultant

<p>Die Corona-Krise ist weiterhin in aller Munde und wird uns mit hoher Wahrscheinlichkeit noch etwas länger begleiten. Wie man aus unterschiedlichen Statistiken erfährt, schwanken die Fallzahlen weiter und sorgen für zusätzliche Restriktionen. Diese werden eingesetzt, um die Verbreitung des Virus weitestgehend zu stoppen. Ein wichtiger Aspekt stellt dabei die Einhaltung eines Mindestabstands zu anderen Personen dar. Die empfohlene Distanz liegt bei ungefähr 1,5 Metern, um so bestmöglich den direkten Kontakt zu anderen Personen zu vermeiden. Besonders in Zeiten, in denen die Zahlen an Corona-Infizierten erneut ansteigen, ist es umso wichtiger, dass ein solcher Abstand eingehalten wird. Immer öfter wird dieser Mindestabstand jedoch vergessen.</p><p>Aus diesem Grund wurde mittels eines <a href="https://blog.codecentric.de/tag/machine-learning-2/">Machine-Learning</a> -Ansatzes die Anwendung „Smart DistancR“ entwickelt. Der Smart DistancR ermöglicht eine perspektivisch korrekte Distanzmessung zwischen allen sichtbaren Personen auf einem Kamerabild und kann eine Mitteilung herausgeben, falls der Mindestabstand zwischen einer bestimmten Paarung nicht eingehalten werden sollte. Die Verarbeitung verläuft dabei vollständig lokal und somit ohne jegliche Cloud-Anbindung und ohne Speicherung von Bildmaterialien.</p><p>Das folgende Video zeigt das Ergebnis des Distanzmessers, das mithilfe von <a href="https://blog.codecentric.de/2017/06/einfuehrung-in-computer-vision-mit-opencv-und-python/">OpenCV</a>  generiert wurde. Die erkannten Personen wurden aus Datenschutzgründen durch Avatare ersetzt.<br /></p>
<video controls>
  <source src="https://media.graphassets.com/n4p7UKzMSKJIYCc6eX65"> 
  Your browser does not support the video tag.
</video>
<p>Um zunächst einen Überblick über das allgemeine Vorgehen zu schaffen, sind hier die einzelnen Schritte, die innerhalb des Prozesses durchgeführt werden, kurz und bündig dargestellt:</p><ul><li>Das Video oder der Videostream wird über eine Schnittstelle (z. B. als Real-Time Streaming Protocol) bereitgestellt.</li><li>Mittels eines trainierten Machine-Learning-Modells werden alle Personen erkannt und die dazugehörigen Bild-Koordinaten berechnet.</li><li>Durch den Kamerawinkel sind die Koordinaten nicht ohne Weiteres für die Distanzmessung nutzbar. Der Fehler, der durch den Betrachtungswinkel entsteht, wird mithilfe perspektivischer Transformation herausgerechnet.</li><li>Alle korrigierten Koordinaten werden in ein zweidimensionales Feld überführt.</li><li>Die Distanzen werden mithilfe von Abständen zwischen bestehenden Referenzpunkten perspektivisch korrekt berechnet und über eine Schnittstelle bereitgestellt.</li></ul><div><a href="https://media.graphassets.com/WF5eHnfkTqe4NFtrn3Xt"><img loading="lazy" src="https://media.graphassets.com/WF5eHnfkTqe4NFtrn3Xt" alt="Schematische Darstellung des Prozesses vom Smart DistancR" width="1024" height="290" /></a> <p>Schematische Darstellung des Prozesses vom Smart DistancR</p></div><p>Das Hauptziel des Smart DistancRs besteht darin, Distanzen zwischen Personen in einem Video perspektivisch korrekt zu berechnen. Für die Umsetzung war es jedoch auch wichtig, dass die Hardware leichtgewichtig ist und so die Einsetzbarkeit möglichst einfach gestaltet werden kann. Deswegen wurde das Projekt für die Nutzung auf einem Raspberry Pi 4 und dem Coral Device von Google, das als Edge TPU für die Inferenz genutzt wird, optimiert. Für die Inferenz mit dem Coral Device wurde das trainierte Machine-Learning-Modell von einem TensorFlow-Modell in ein TensorFlow-Lite-Modell überführt.</p><div><a href="https://media.graphassets.com/j9f4TPFFSXthjkrJPUQZ"><img loading="lazy" src="https://media.graphassets.com/j9f4TPFFSXthjkrJPUQZ" alt="Verwendete Hardware für den Smart DistancR" width="1024" height="290" /></a> <p>Verwendete Hardware für den Smart DistancR</p></div><h2>Umsetzung des Smart DistancRs im Detail</h2><p>Für ein tieferes Verständnis wird im Folgenden jeder einzelne Prozessschritt im Detail erläutert. Da es bereits umfangreiche Artikel zu Object-Detection-Modellen gibt, wird hierbei lediglich der eigentliche Prozess erklärt.</p><h3>Personenerkennung</h3><p>Für die Erkennung von Personen bietet ein Object-Detection-Ansatz die optimale Lösung. In einer perfekten Welt mit unbegrenzter Rechenpower könnte man dafür sehr genaue Ansätze, wie Faster R-CNN, verwenden. Im Fall des vorliegenden Projekts bestehen aber gewisse Hardware-Einschränkungen. Zum einen soll die Lauffähigkeit der Anwendung auf einem Raspberry Pi 4 gewährleistet sein, zum anderen soll die Inferenz zur Erkennung von Objekten auf einem Google Coral Device durchgeführt werden. Da bereits viele vortrainierte Object-Detection-Modelle für das Coral Device optimiert sind <a href="https://coral.ai/models/object-detection/" target="_blank">[1]</a> , wurde ein auf MS COCO (Microsoft Common Objects in Context) trainiertes SSD-MobileNet-V2-Modell verwendet. Da der MS-COCO-Datensatz die Klasse „Person“ enthält und die Inferenzzeit bei 7,6 ms liegt, war dies die beste Option für ein Proof of Concept.</p><h3>Perspektivische Korrektur</h3><p>Den Kern der Anwendung stellt die perspektivische Korrektur dar. Mittlerweile wurden verschiedene Lösungen eines Distanzmessers umgesetzt. Darunter sind zum einen Anwendungen, die auf unterschiedlichen Sensoren basieren, zum anderen sind es Anwendungen, die ebenfalls Kamerabilder zur Distanzmessung verwenden. Viele dieser Alternativen gehen dabei ähnlich wie der Smart DistancR vor und beginnen mit der Erkennung von Personen. Danach wird häufig einfach die Distanz (euklidische Distanz) zwischen den erkannten Köpfen oder Füßen berechnet und der Wert als Ergebnis für die Distanz bereitgestellt. Bei diesem Verfahren wird jedoch nicht der perspektivische Fehler, der bei der Aufnahme entsteht, berücksichtigt.</p><p>Die meisten Kameras führen die Aufnahme nicht aus der Vogelperspektive, sondern von vorne oder von der Seite durch. Distanzen, die mit den Koordinaten aus diesem Kamerabild berechnet werden, sind perspektivisch inkorrekt. Durch den Kamerawinkel sind Personen, die nebeneinander stehen, im berechneten Wert weiter voneinander entfernt als Personen mit der gleichen Distanz hintereinander. Es geht sogar so weit, dass das Ergebnis mit einem flacheren Kamerawinkel immer schlechter wird. Der dabei entstehende Fehler ist in der dargestellten Animation zu erkennen.</p>
<p><img loading="lazy" src="https://media.graphassets.com/GMJ1IyGtS0vypvm6maq6" alt="Je steiler der Kamerawinkel, desto größer wird der perspektivische Fehler" width="1024" height="290" /></p>

<div><a href="https://media.graphassets.com/GMJ1IyGtS0vypvm6maq6"><img loading="lazy" src="https://media.graphassets.com/GMJ1IyGtS0vypvm6maq6" alt="Je steiler der Kamerawinkel, desto größer wird der perspektivische Fehler" width="1024" height="290" /></a>
<p><img width="778" height="592" src="https://media.graphassets.com/GMJ1IyGtS0vypvm6maq6" alt="Je flacher der Kamerawinkel, desto größer wird der perspektivische Fehler" /></p>
<p>Je flacher der Kamerawinkel, desto größer wird der perspektivische Fehler</p></div>
<p><img width="778" height="592" src="https://media.graphassets.com/GMJ1IyGtS0vypvm6maq6" alt="Hotwire: Showing smooth navigation with Turbo Driv" /></p>
<p>Um eine korrekte Distanz berechnen zu können, muss die Kamera entweder aus der Vogelperspektive die Aufnahmen erzeugen oder der Kamerawinkel muss herausgerechnet und somit die Perspektive korrigiert werden.</p><p>Die Korrektur wird mithilfe einer projektiven Transformation realisiert. Diese ermöglicht es, mittels der Koordinaten aus der einen Perspektive und einer sogenannten Transformationsmatrix (Homographie) Koordinaten aus einer anderen Perspektive zu berechnen. Für den vorliegenden Anwendungsfall können so Positionen aus dem Kamerabild in die Vogelperspektive überführt werden.<br /> <img loading="lazy" width="732" height="642" src="https://media.graphassets.com/oatBs06zQKeWbXGYWf9A" alt="Smart DistancR projektive Transformation" /></p><p>Die Korrektur der Koordinaten berechnet sich mithilfe folgender Gleichung:</p><p>$\begin{bmatrix} x‘ \\ y‘ \\ z‘ \end{bmatrix} = \begin{bmatrix} h_{11} & h_{12} & h_{13} \\ h_{21} & h_{22} & h_{23} \\ h_{31} & h_{32} & h_{33} \end{bmatrix}. \begin{bmatrix} x \\ y \\ z \end{bmatrix}$</p>
<p>Hierbei stehen x, y und z für eine Koordinate in der ursprünglichen Perspektive und x’, y’ und z’ für eine Koordinate der Ziel-Perspektive. Die Matrix H repräsentiert die Homographie. Mit ihr ist es mit der dargestellten Multiplikation möglich, jeden Punkt aus der einen Ebene in die andere Ebene zu überführen. Um die Homographie zu berechnen, werden vier übereinstimmende Koordinaten aus beiden Perspektiven benötigt. Mithilfe dieser Koordinaten kann die Homographie H mit folgender Gleichung berechnet werden:</p><p>$PH =\\ \begin{bmatrix} -x_1 & -y_1 & -1 & 0 & 0 & 0 & x_1x_1′ & y_1x_1′ & x_1′ \\ 0 & 0 & 0 & -x_1 & -y_1 & -1 & x_1y_1′ & y_1y_1′ & y_1′ \\ -x_2 & -y_2 & -1 & 0 & 0 & 0 & x_2x_2′ & y_2x_2′ & x_2′ \\ 0 & 0 & 0 & -x_2 & -y_2 & -1 & x_2y_2′ & y_2y_2′ & y_2′ \\ -x_3 & -y_3 & -1 & 0 & 0 & 0 & x_3x_3′ & y_3x_3′ & x_3′ \\ 0 & 0 & 0 & -x_3 & -y_3 & -1 & x_3y_3′ & y_3y_3′ & y_3′ \\ -x_4 & -y_4 & -1 & 0 & 0 & 0 & x_4x_4′ & y_4x_4′ & x_4′ \\ 0 & 0 & 0 & -x_4 & -y_4 & -1 & x_4y_4′ & y_4y_4′ & y_4′ \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\\ \end{bmatrix} \begin{bmatrix}h1 \\ h2 \\ h3 \\ h4 \\ h5 \\ h6 \\ h7 \\ h8 \\h9 \end{bmatrix} = \begin{bmatrix}0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\1 \end{bmatrix}$</p><p>Alternativ kann man die Funktion <em><a href="https://docs.opencv.org/4.x/d9/d0c/group__calib3d.html#ga4abc2ece9fab9398f2e560d53c8c9780" target="_blank">findHomography</a> </em>, die OpenCV bereitstellt, ganz einfach nutzen.</p><p>Die vier übereinstimmenden Koordinaten sollten möglichst exakt sein und im besten Fall nicht zu nah beieinander liegen. Hat man diese Koordinaten gewählt und die Homographie berechnet, kann jeder Punkt aus der einen Perspektive in die andere übertragen werden. Wie in der nachfolgenden Abbildung zu sehen, kann demnach auch die Position einer erkannten Person übertragen werden.</p><div><a href="https://media.graphassets.com/m9wjJCMJQkWi47SNVSVx"><img loading="lazy" src="https://media.graphassets.com/m9wjJCMJQkWi47SNVSVx" alt="Mapping anhand von vier unterschiedlichen Referenzpunkten" width="1024" height="290" /></a> <p>Mapping anhand von vier unterschiedlichen Referenzpunkten</p></div><h3>Zusammenführung zur Anwendung</h3><p>Nachdem alle Bausteine für die Distanzmessung entwickelt sind, gilt es, alles korrekt zusammenzuführen. Wie bereits zu Anfang erwähnt, werden zunächst Personen erkannt, wobei die Füße als Anker für die Distanz verwendet werden. Die daraus entstehenden Koordinaten werden mithilfe der Homographie in eine 2D-Ebene umgerechnet. Die euklidische Distanz (d) der beiden Koordinaten (P,Q) in der 2D-Ebene stellt die berechnete Distanz in Pixeln dar. Diese berechnet sich wie folgt:</p><p>$d(P,Q) = \sqrt{(q_1 – p_1)^2 + (q_2 – p_2)^2}$</p><p>Um diesen Wert in Zentimeter umzurechnen, wird das Maß für Zentimeter pro Pixel benötigt (cm/p). Für die Berechnung dieses Wertes kann eine bekannte Distanz, wie etwa der Abstand zwischen zwei Referenzpunkten, verwendet werden. Da die Distanz in Pixeln in der 2D-Ebene bekannt ist, kann somit der Wert für cm/Pixel berechnet werden.<br /> Um Warnhinweise für eine Unterschreitung der einzuhaltenden Distanz zwischen zwei Personen herausgeben zu können, wurde ein Threshold von 150 cm eingebaut. Wird dieser Abstand nicht eingehalten, kann ein gewünschtes Event getriggert werden. In diesem Fall wird die Linie zwischen den Personen rot dargestellt (siehe Video).</p><h3>Weiteres Vorgehen beim Smart DistancR</h3><p>Die eigentlich Distanzberechnung ist somit abgeschlossen. Weiterführend kann die Anwendung aber um zusätzliche Aspekte und Funktionalitäten erweitert werden. In unserem Fall wurde eine Schnittstelle entwickelt, die die Daten direkt an einen MQTT Broker und somit an eine IoT Cloud weitergeben kann.</p><h2>Referenzen</h2><p>[1] <a href="https://coral.ai/models/object-detection/">Coral: Object detecion – Trained models</a> </p><p></p>

Smart DistancR – Perspektivisch korrekte Distanzmessung zwischen Personen

Knowledge und Task Management in Notion

Die Welt der Frontend-Entwicklung hat sich erneut verändert und diesmal ist React 19 der Vorreiter. Mit dieser Version bringt React eine Vielzahl neuer Funktionen und Verbesserungen. Aber die wohl aufregendste Neuerung ist der brandneue Compiler, welcher React 19 bereits voraussetzt. In diesem Artikel werfen wir einen detaillierten Blick auf die wichtigsten Änderungen und tauchen in die Funktionen und Vorteile dieses neuen Compilers ein. Zudem wird es einen kurzen Überblick über die anderen Neuerungen geben. Bevor wir jedoch zu tief einsteigen, sei erwähnt, dass die neue Version noch als Release Candidate gekennzeichnet ist. Die neuen Features sind also alle noch mit Vorsicht zu genießen.

# Was genau ist neu in React 19?

## Einführung eines neuen Compilers
Ein Kernelement der neuen Version ist der neue Compiler, der neben React 19 erscheint. Er wurde entwickelt, um den kompilierten Code effizienter zu machen und so die Leistung zu optimieren. Dadurch sollen sich Entwickler zukünftig weniger Gedanken um Performance-Optimierungen machen.
Der React Compiler ist das Herzstück der neuen Version und bringt viele Eigenschaften mit sich. Zum einen ist er als Open-Source-Projekt verfügbar, zum anderen arbeitet er als Build-Time-Only-Tool und benötigt daher keine Laufzeitunterstützung. Außerdem wird derzeit auch an einer Rust Version gearbeitet, welche mit Blick auf die Performance nochmal besser werden soll [1]. Um die Arbeit mit dem Compiler zu erleichtern, gibt es auch ein dazugehöriges ESLint Plugin. [2]

Der initiale Release des React Compilers konzentriert sich hauptsächlich auf die Verbesserung der Update-Performance (Re-Rendering bestehender Komponenten und Memoization von Hooks), was besonders bei komplexen Anwendungen von Vorteil ist. Bisher wurde jegliche Art von Memoizations durch Hooks, wie useMemo, useCallback und React.memo, realisiert. Mit Hilfe des Compilers werden solche Stellen im Code jetzt vollautomatisiert. Heißt konkret: Das, was nicht neu berechnet werden muss, wird auch nicht neu berechnet. [2]

React 18 ohne Compiler
```
const Component = () => {
  const [count, setCount] = useState(0);
  const calculation = useMemo(() => expensiveCalculation(count), [count]);

  return (
    <div>
 Calculation: {calculation}
      …
    </div>
  );
};
```

React 19 mit Compiler
```
const Component = () => {
  const [count, setCount] = useState(0);
  // memoization without useMemo
  const calculation = expensiveCalculation(count)

  return (
    <div>
 Calculation: {calculation}
      …
    </div>
  );
};
```

Gleiches gilt für das Re-Rendering von Komponenten. Folgendes Beispiel zeigt eine Komponente zur Anzeige von ToDos und eine Komponente, um weitere Todos hinzuzufügen. Wenn keinerlei Memoization hinzugefügt ist, wird die Komponente und all ihre Kinder-Komponenten vollständig neu gerendert, sobald sich die Liste von ToDos ändert. Mit Hilfe des React Compilers und der dazugehörigen Memoization wird automatisch erkannt, dass die Komponente zum Hinzufügen von ToDos (AddNewTodoComponent) unabhängig von den angezeigten ToDos ist und dementsprechend nicht neu gerendert werden muss.

```
const TodoList = () => {
  const todos = useTodos();
  return (
    <div>
      <span>{todos.length} todos</span>
      {todos.map((todo) => (
        <TodoEntry key={todo.id} todo={todo} />
      ))}
      <AddNewTodoComponent />
    </div>
  );
}
```

Fazit: Der neue React Compiler eliminiert die Notwendigkeit von useMemo und useCallback, was zu einer effizienteren und schlankeren Codebasis führt.

## Server Components
Bisher wurden React-Komponenten lediglich clientseitig gerendert. Mit Next.js gibt es seit einiger Zeit die Möglichkeit, Anwendungen mit Server Components zu bauen. Hierbei handelt es sich um Komponenten, die lediglich auf dem Server gerendert werden. Mit React 19 werden diese nun auch voll integriert. Bei der Verwendung gilt es zwischen Server Components mit und ohne Server zu unterscheiden. Ohne Server bedeutet dabei, dass das Server Side Rendering zur Build-Time durchgeführt wird und so statische Inhalte (z.B. aus unterschiedlichen Dateien) eingelesen werden können. Im Gegensatz dazu werden die Server Components unter der Nutzung eines Web Servers bei jeder Anfrage neu gerendert. [4] Da die Ausführung auf dem Server stattfindet, können Server Actions genutzt werden und die Komponenten müssen keine zusätzliche API ansprechen. Dadurch können etwa Datenbankabfragen direkt durchgeführt werden. [3]

```
import db from './database';
export Todo = async ({id}) => {
  const todo = await db.todos.get(id);
  return (
    <div>
      <Author id={todo.authorId} />
      <p>{todo}</p>
    </div>
  );
}
```

**Vorteile von Server Components:**
- SEO: Bessere Sichtbarkeit in Suchmaschinen, da der Inhalt serverseitig gerendert wird.
- Performance: Schnellerer initialer Pageload und insgesamt bessere Performance durch serverseitige Ausführung.
- Server Side Execution: Bessere Handhabung von API-Calls und anderen serverseitigen Aufgaben.
- Build-Time Rendering: Komponenten können zur Build-Time gerendert und dann als statischer Content ausgeliefert werden.

## Server Actions
Neben Server Components werden mit React 19 auch Server Actions eingeführt. Hierbei wird es möglich, asynchrone Funktionen auf dem Server auszuführen. Hier genügt eine Annotation mit ‘use server’, um eine Action als serverseitige Action zu definieren. Wenn eine solche Funktion aufgerufen wird, schickt React eine Anfrage an den Server, auf dem dann die Funktion aufgerufen wird. [5] Eine Server Action kann etwa wie folgt aussehen:

```
"use server";

export createTodoAction = async () => {
  await db.todos.create();
}
```

Diese Server Action kann dann sowohl bei Server Components, als auch bei Client Components (mit “use client” annotiert) eingebunden werden. So kann selbst bei einer Komponente, in welcher die Action auf dem Client getriggert werden soll, diese trotzdem server-seitig durchgeführt werden. [5]

Beispiel:
```
“use client”
import {createTodoAction} from './actions';

const Overview = () => {
  …
  <button onClick={createTodoAction} />
  …
}
```

## Neue Hooks und weitere Features
React 19 bringt eine Vielzahl neuer Hooks und Features, welche die Entwicklung vereinfachen und optimieren.

### Actions
Eine häufige Aufgabe in React-Apps ist die Durchführung von Datenmutationen und die anschließende Aktualisierung des Zustands. Funktionen die solche asynchronen Transitionen benutzen, werden als "Actions" bezeichnet. Bisher mussten Entwickler manuell mit Pending-Zuständen, Fehlern und optimistischen Updates umgehen. Dies konnte etwa durch useState realisiert werden. Mit React 19 wird dies durch die Einführung von Actions vereinfacht. Dies kann mit Hilfe von useTransition etwa wie folgt aussehen: [3]

```
const [name, setName] = useState("");
 const [error, setError] = useState(null);
 const [isPending, startTransition] = useTransition();


 const handleSubmit = () => {
   startTransition(async () => {
     const error = await updateName(name);
     if (error) {
       setError(error);
       return;
     }
     redirect("/path");
   })
 };
```

### use( ) - Die neue API für Promises und Contexts

Der use Hook stellt eine neue Schnittstelle dar und ermöglicht es, auf Ressourcen während des Renderns zuzugreifen, was weniger Bedarf an useEffect und useState bedeutet. Ressourcen können in diesem Fall etwa Promises oder Contexts sein. [3]

```
import { use } from 'react';

const NewsComponent = ({ newsPromise }) => {
  const news = use(newsPromise);
  const theme = use(ThemeContext);
  // ...
```

### Weitere Features und Hooks

**Ref als Prop**

Zukünftig wird es nicht mehr nötigsein forwardRef zu benutzen um ein ref durchzureichen. Ref wird dementsprechend ein standard prop für Komponenten. [3]

**useOptimistic**

Der useOptimistic Hook ermöglicht temporäre Updates mit optimistischen Werten. Dies ist besonders nützlich, wenn man dem Benutzer sofortiges Feedback geben möchte, während die tatsächlichen Daten noch verarbeitet werden. [3]

**useFormStatus**

Der useFormStatus Hook kann den State des Formulars lesen und ermöglicht so eine bessere Handhabung von Formularzuständen und Validierungen in untergeordneten Komponenten. [3]

Neben den hier genannten Features gibt es noch weitere kleine Neuerungen, die für den ein oder anderen sicherlich auch interessant sind. Dafür möchte ich an dieser Stelle aber direkt auf die Release Notes(https://react.dev/blog/2024/04/25/react-19) von React 19 hinweisen.

# Fazit
React 19 markiert einen bedeutenden Fortschritt in der Frontend-Entwicklung. Der neue Compiler bringt nicht nur eine drastisch verbesserte Performance, sondern auch eine Vielzahl von neuen Möglichkeiten und Optimierungen, die Entwicklern das Leben erleichtern. Mit den neuen Tools und Verbesserungen wird die Entwicklung von React-Anwendungen weitaus effizienter und leistungsfähiger als zuvor.

# Quellen

[1] [React Compiler Development Guide](https://github.com/facebook/react/blob/main/compiler/docs/DEVELOPMENT_GUIDE.md) (Abrufdatum: 12.07.2024)

[2] [React Compiler](https://react.dev/learn/react-compiler) (Abrufdatum: 28.06.2024)

[3] [React 19 RC](https://react.dev/blog/2024/04/25/react-19) (Abrufdatum: 28.06.2024)

[4] [React Server Components](https://react.dev/reference/rsc/server-components) (Abrufdatum: 12.07.2024)

[5] [Server Actions](https://react.dev/reference/rsc/server-actions) (Abrufdatum: 28.06.2024)

React ist tot, lang lebe React - React 19 ist da

The world of frontend development has changed once again, and this time React 19 is leading the way. This version brings a variety of new features and improvements, but the most exciting innovation is the brand new compiler, which already requires React 19. In this article, we shall take a detailed look at the changes and delve into the features and benefits of this new compiler. Additionally, there will be a brief overview of the other new additions. However, before we dive in too deep, it should be noted that the new version is still labeled as a Release Candidate. Therefore, all new features should be used with caution.

# What exactly is new in React 19?

## Introduction of a New Compiler

A key element of the new version is the new compiler that comes with React 19. It has been developed to make the compiled code more efficient, thus optimizing performance. This means that developers will need to worry less about performance optimizations in the future. The React Compiler is the core of the new version and brings many features with it. Firstly, it is available as an open-source project. Secondly, it works as a build-time-only tool and does not require runtime support. Additionally, a Rust version is currently in development, which is expected to further improve performance [1]. To facilitate working with the compiler, there is also an associated ESLint plugin available[2].

The initial release of the React Compiler focuses mainly on improving update performance (re-rendering existing components and memoization of hooks), which is especially beneficial for complex applications. Previously, all types of memoizations were achieved through the use of hooks like useMemo, useCallback, and React.memo. With the help of the compiler, these parts of the code are now fully automated. In concrete terms, whatever does not need to be recalculated, won’t be. [2]

React 18 without a compiler
```
const Component = () => {
  const [count, setCount] = useState(0);
  const calculation = useMemo(() => expensiveCalculation(count), [count]);

  return (
    <div>
 Calculation: {calculation}
      …
    </div>
  );
};
```

React 19 with a compiler
```
const Component = () => {
  const [count, setCount] = useState(0);
  // memoization without useMemo
  const calculation = expensiveCalculation(count)

  return (
    <div>
 Calculation: {calculation}
      …
    </div>
  );
};
```

The same applies to re-rendering components. The following example shows a component for displaying ToDos and a component for adding more ToDos. Without any memoization, the component and all its child components will be re-rendered whenever the list of ToDos changes. With the help of the React Compiler and its associated memoization, it is automatically recognized that the component for adding ToDos (AddNewTodoComponent) is independent of the displayed ToDos and therefore does not need to be re-rendered.

```
const TodoList = () => {
  const todos = useTodos();
  return (
    <div>
      <span>{todos.length} todos</span>
      {todos.map((todo) => (
        <TodoEntry key={todo.id} todo={todo} />
      ))}
      <AddNewTodoComponent />
    </div>
  );
}
```

Conclusion: The new React Compiler eliminates the need for useMemo and useCallback, leading to a more efficient and streamlined codebase.

## Server Components
Previously, React components were only rendered on the client side. With Next.js, it has been possible to build applications with Server Components for some time. These are components that are rendered only on the server. With React 19, these are now fully integrated. When using them, it is important to distinguish between Server Components with and without a server. Without a server means that Server Side Rendering is done at build time, allowing static content (e.g., from various files) to be loaded. In contrast, Server Components using a web server are re-rendered with each request [4]. Since the execution takes place on the server, Server Actions can be utilized, and the components do not need to call an additional API. This allows, for example, direct database queries to be performed [3].

```
import db from './database';
export Todo = async ({id}) => {
  const todo = await db.todos.get(id);
  return (
    <div>
      <Author id={todo.authorId} />
      <p>{todo}</p>
    </div>
  );
}
```

**Benefits of Server Components**
- SEO: Better visibility in search engines since the content is rendered server-side.
- Performance: Faster initial page load and overall better performance due to server-side execution.
- Server Side Execution: Better handling of API calls and other server-side tasks.
- Build-Time Rendering: Components can be rendered at build time and then delivered as static content.

## Server Actions
Alongside Server Components, React 19 also introduces Server Actions. This allows asynchronous functions to be executed by the server. By simply annotating a function with ‘use server’, it can be defined as a server-side action. When such a function is called, React sends a request to the server where the function is then executed [5]. A Server Action might look like this:

```
"use server";

export createTodoAction = async () => {
  await db.todos.create();
}
```

This Server Action can be used in both Server Components and Client Components (annotated with “use client”). This means that even if an action is triggered on the client side, it can still be executed server-side [5].

Example:
```
“use client”
import {createTodoAction} from './actions';

const Overview = () => {
  …
  <button onClick={createTodoAction} />
  …
}
```

## New Hooks and Other Features
React 19 brings a variety of new hooks and features that simplify and optimize development.

### Actions
A common task in React apps is performing data mutations and subsequently updating the state. Functions that use such asynchronous transitions are called "Actions". Previously, developers had to manually handle pending states, errors, and optimistic updates, often using useState. With React 19, this is simplified through the introduction of Actions. This can be achieved using useTransition as shown below: [3]

```
const [name, setName] = useState("");
 const [error, setError] = useState(null);
 const [isPending, startTransition] = useTransition();


 const handleSubmit = () => {
   startTransition(async () => {
     const error = await updateName(name);
     if (error) {
       setError(error);
       return;
     }
     redirect("/path");
   })
 };
```

### use( ) - The New API for Promises and Contexts
The use hook provides a new interface, allowing access to resources during rendering, which reduces the need for useEffect and useState. Resources in this context can refer to Promises or Contexts. [1]

```
import { use } from 'react';

const NewsComponent = ({ newsPromise }) => {
  const news = use(newsPromise);
  const theme = use(ThemeContext);
  // ...
```

### Additional Features and Hooks

**Ref as Prop**

In the future, there will be no need to use forwardRef to pass a ref. Ref will become a default prop for components [3].

**useOptimistic**

The useOptimistic hook allows for temporary updates with optimistic values. This is particularly useful for providing immediate feedback to users while the actual data is still being processed [3].

**useFormStatus**

The useFormStatus hook can read the state of a form, enabling better handling of form states and validations in child components [3].

Besides the features mentioned here, there are other small enhancements that might be interesting for some. For more details, I would directly refer to the Release Notes of React 19.

# Conclusion
React 19 marks a significant advancement in frontend development. The new compiler not only brings with it a dramatically improved performance but also offers a variety of new possibilities and optimizations that make developers' lives easier. With the new tools and improvements, developing React applications will become much more efficient and powerful than before.

# Sources

[1] [React Compiler Development Guide](https://github.com/facebook/react/blob/main/compiler/docs/DEVELOPMENT_GUIDE.md) (Accessed on: 12.07.2024)

[2] [React Compiler](https://react.dev/learn/react-compiler) (Accessed on: 28.06.2024)

[3] [React 19 RC](https://react.dev/blog/2024/04/25/react-19) (Accessed on: 28.06.2024)

[4] [React Server Components](https://react.dev/reference/rsc/server-components) (Accessed on: 12.07.2024)

[5] [Server Actions](https://react.dev/reference/rsc/server-actions) (Accessed on: 28.06.2024)

React is dead, long live React - React 19 is here

Profilbild von Dominik Fladung im Hemd und mit Brille

Wir Softwareentwickler leben in einem ständigen Dilemma. Jede Funktionalität der Software sollte durch *Unit-Tests* und *Integrationstest* abgesichert werden. Es sollten dabei so viel Tests wie nötig, aber nur so wenige wie möglich geschrieben werden. 

Schreiben wir zu wenige Tests, dann sind nicht alle Funktionalitäten unserer Software ausreichend abgesichert. Zu viele Tests bedeuten teure Entwicklungszeit, die wir in unnötige Tests investieren.
Da sich die Software im Laufe der Zeit stetig verändert, müssen wir die Tests auch immer wieder anpassen. Mit der puren Anzahl der Tests steigt natürlich auch der Aufwand für die Pflege unserer Testbasis.

Ein recht aufwendiger Teil der Tests ist die Bereitstellung der Testdaten. Daher werden ziemlich schnell standarisierte Testdaten bzw. *Test Fixtures* in den Projekten genutzt. Ein Vorteil dieser *Test Fixtures* ist der reduzierte Aufwand bei den Anpassungen. Statt hunderte von Tests zu ändern, müssen nur einige wenige Bereitstellungsmethoden aktualisiert werden.

Für diese Bereitstellungsmethoden werden in den eigenen *JUnit 5*-Tests diverse Ansätze herangezogen, der *Extension-Mechanismus* des Frameworks aber häufig außer Acht gelassen. Wie dieser genutzt werden kann, werde ich im Folgenden an einem einfachen Test vorstellen.  

## Der JUnit 5 Extension-Mechanismus

Der _Extension-Mechanismus_ modifiziert das Verhalten von Testklassen oder -methoden. Vor _Junit 5_ verwendete _JUnit_ nur die Erweiterungspunkte `TestRunner` und `Rule`. _JUnit 5_ ersetzt diese durch eine vollständige _Extension-API_. Die API gestattet es an fünf Extension-Points in den Lifecycle eines Tests  einzugreifen. In diesem Beitrag nutzen wir den  Extension-Point _Parameter Resolution_, aber dazu kommen wir später.

## Der Bibliotheksbenutzer, seine Ausleihe und die Gebühren aka die Domäne

Ein Problem und seine Lösung erklärt man am einfachsten an einem prägnanten Beispiel. Dieses Beispiel bedient sich an meinen IT-Erfahrungen aus der Studentenzeit. Ein Bibliotheksnutzer hat diverse Ausleihen von Büchern und ggf. stehen Gebühren für die Nutzung oder überfällige Medien an.

## Ein erster Test

In unserem Beispiel werden die aktuellen Gebühren für einen Nutzeraccount berechnet. Dazu wird ein Account für einen Bibliotheksnutzer erstellt und zwei Ausleihen hinzugefügt.
Da eine der  beiden Ausleihen überfällig ist, steht eine Mahngebühr von 3 Euro an.

```java
class LibraryTest {
  @Test
  void currentFees() {
    Patron patron = Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    Booking booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    Booking booking14 = Boocking.media(book14).till(LocalDate.now().plusDays(2)).build()

    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Für den ersten Test eine Menge Code für die Erstellung der Testdaten. Alle weiteren Tests mit ähnlichen Voraussetzungen benötigen ähnliche Codefragmente. Daher sollten wir versuchen diese Fragmente bestmöglich wiederzuverwenden.

## Weniger Boilerplate-Code

Für weitere Tests in der Klasse `LibraryTest` zentralisieren wir das Erstellen der Testdaten.
Die bekannteste Möglichkeit dafür ist eine mit `@BeforeEach` annotierte Methode.

```java
class LibraryTest {
  private Patron patron;
  private Booking booking9;
  private Booking booking14;

  @BeforeEach
  void setUp() {
    Patron patron = Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
    Book book9 = Book.title("Gevatter Tod").author("Terry Prattchet").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    Booking booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    Booking booking14 = Boocking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFees() {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Nun können sich alle Testmethoden die *Text Fixture* teilen. Da die `setUp`-Methode vor jedem Test aufgerufen wird, werden diese Daten leider auch für Tests erstellt, die sie gar nicht benötigen.

## Parameter Resolver in JUnit 5

*JUnit 5* erlaubt es, Parameter an Test und Lifecycle-Methoden zu übergeben. Dafür können eigene `ParameterResolver` implementiert werden.

```java
public class PatronParameterResolver implements ParameterResolver {

  @Override
  public boolean supportsParameter(ParameterContext parameter, ExtensionContext extension) {
      return parameter.getParameter().getType() == Patron.class;
  }

  @Override
  public Patron resolveParameter(ParameterContext parameter, ExtensionContext extension) {
    return Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
  }
}
```

Der `PatronParameterResolver` ersetzt alle Methodenparameter vom Typ `Patron` mit der Instanz, die von der Methode `resolveParameter` erzeugt wird. Wir dürfen nicht die `@ExtendWith` Annotation vergessen, sonst weiß _JUnit 5_ nicht, woher der `Patron`kommen soll.

Die Test-Klasse verkürzt sich nun um den vom `PatronParameterResolver` generierten Kunden.

```java
@ExtendWith(PatronParameterResolver.class)
class LibraryTest {
  private  Booking booking9;
  private  Booking booking14;

  @BeforeEach
  void setUp() {
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    Booking booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    Booking booking14 = Boocking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFees(Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Der Bibliotheksnutzer wird nun nur noch für die Testmethoden erzeugt, die diesen auch tatsächlich benötigen. Nur schade, dass es immer derselbe Nutzer ist. Kann man das nicht ändern?

## Variationen mit Annotationen

Eine Annotation am Parameter kann durch den Parameter Resolver ausgewertet werden und zur Modifizierung der Werte genutzt werden. Mit der Annotation `@Fixture` sind dann die folgenden Tests möglich.

```java
@ExtendWith(PatronParameterResolver.class)
class LibraryTest {
  private Booking booking9;
  private Booking booking14;

  @BeforeEach
  void setUp() {
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    Booking booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    Booking booking14 = Boocking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFeesAdult(@Fixture("Jens") Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();
    assertEquals(3, account.getCurrentFees());
  }

  @Test
  void currentFeesChild(@Fixture("Christopher") Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();
    assertEquals(2, account.getCurrentFees());
  }
}
```

Der `PatronParameterResolver` entscheidet mit Hilfe der `@Fixture` Angabe, welcher Bibliotheksnutzer erstellt werden soll. Der zweite Bibliotheksnutzer bekommt geringere Mahngebühren, weil er noch ein Kind ist. 

Wir verwenden an dieser Stelle _Personas_, um unseren Tests, im wahrsten Sinne des Wortes, ein Gesicht zu geben. Die Persona _Jens Kaiser_ ist ein älterer Herr, der gelegentlich die Bibliothek besucht und _Christopher Robin_ ist ein kleiner Junge mit einem Teddybär.

## Das geht auch generisch

Häufig hat man es nicht nur mit einer Domänenklasse zu tun, sondern mit sehr vielen. Daher kann ein Großteil der Implementierung in einer generische Basisklasse verschoben werden.

```java
public class PatronFixtureParameterResolver 
      extends AbstractFixtureParameterResolver<Customer, Long> { 
  public PatronFixtureParameterResolver() {
    super(Patron.class, x -> (long) x);
  }

  @Override
  protected Patron createInstance(Long identifier, String persona) {
    String id = "id-%03d".formatted(identifier);
    return switch (persona) {
       case "Christopher" -> Patron.id(id).name("Christopher Robin").fees(CHILD).build();
       case "Jens", "default" -> Patron.id(id).name("Jens Kaiser").fees(ADULT).build();
       default -> throw new ParameterResolutionException("unknown patron: " + persona);   
     }
  }
}
```

Der `PatronFixtureParameterResolver` erbt von dem `AbstractFixtureParameterResolver`.
Dieser erzeugt nicht nur eine Instanz der gewünschten Klasse, sondern beherrscht auch Collections und Arrays dieser Klasse und wertet die `@Fixture` Annotation aus. Der `PatronFixtureParameterResolver` kümmert sich nur noch um die Erzeugung der Varianten. 

```java
public abstract class AbstractFixtureParameterResolver<T, I> implements ParameterResolver {
    private final Class<T> type;
    private final Function<Integer, I> identifierMapper;

    protected AbstractFixtureParameterResolver(Class<T> type, Function<Integer, I> mapper) {
        this.type = type;
        this.identifierMapper= mapper;
    }

    private boolean isCollection(Parameter parameter) {
        ParameterizedType type = (ParameterizedType) parameter.getParameterizedType();
        return type.getActualTypeArguments()[0] == type;
    }

    private boolean isArray(Class<?> parameterType) {
        return parameterType.isArray() && parameterType.getComponentType() == type;
    }

    @Override
    public boolean supportsParameter(ParameterContext context, ExtensionContext extension) {
        Parameter parameter = context.getParameter();
        Class<?> parameterType = parameter.getType();
        return parameterType == type || isArray(parameterType) || isCollection(parameter);
    }

    protected abstract T createInstance(I identifier, String variation);

    @Override
    @SuppressWarnings("unchecked")
    public Object resolveParameter(ParameterContext context, ExtensionContext extension) {
        Optional<Fixture> fixture = context.findAnnotation(Fixture.class);
        List<String> variations = fixture.map(Fixture::value).filter(l -> l.length > 0)
            .map(Arrays::asList).orElseGet(() -> List.of("default"));
        Class<?> parameterType = context.getParameter().getType();
        if (parameterType == type) {
            return createInstance(identifierSupplier.apply(0), variations.getFirst());
        }
        int size = fixture.map(Fixture::size).orElse(3);
        int offset = fixture.map(Fixture::offset).orElse(10);
        if (parameterType.isArray()) {
            List<T> list = createStream(offset, size, variations).toList();
            return list.toArray((T[]) Array.newInstance(type, list.size()));
        }
        if (parameterType == List.class) {
            return createStream(offset, size, variations).toList();
        }
        if (parameterType == Set.class) {
            return createStream(offset, size, variations).collect(Collectors.toSet());
        }
        throw new ParameterResolutionException("something went wrong: " + parameterType);
    }

    private Stream<T> createStream(int offset, int size, List<String> variations) {
        return IntStream.range(offset, offset + size)
            .mapToObj(x -> createInstance(identifierMapper.apply(x), 
                variations.get(x % variations.size())));
    }
}
```

## Mehrere Parameter-Resolver

Es geht natürlich auch mit mehreren `ParameterResolvern`. Neben dem `PatronFixtureParameterResolver` wird im folgenden Test auch ein `BookingFixtureParameterResolver` verwendet. Dieser erzeugt die Ausleihen für den Benutzeraccount.

```java 
@ExtendWith(PatronFixtureParameterResolver.class)
@ExtendWith(BookingFixtureParameterResolver.class)
class LibraryTest {
  @Test
  void currentFees(@Fixture("Jens) Patron patron, 
      @Fixture(variations={"Pratchett-2", "Adams+2"}, size=2) List<Booking> bookings) {
    Account account = Account.by(patron).with(bookings)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Der `BookingFixtureParameterResolver` generiert diverse Varianten von `Booking`-Instanzen. In der Testklasse werden keine *Test Fixture* mehr erzeugt. Alle *Test Fixtures* kommen nun aus Parameter Resolvern.

## Fazit

Mit dem _Parameter Resolver_ Extension Point bietet _JUnit 5_ einen mächtigen Mechanismus, um Test-Methoden mit _Test Fixtures_ zu versehen. Wir konnten sehen, dass eigene Parameter-Resolver ohne besonderen Aufwand erstellt und eingebunden werden können.  

Die Testdatenerzeugung mit Parameter-Resolvern bringt einige Vorteile. Der Mechanismus ist integraler Bestandteil des _JUnit 5_ Frameworks. Er ist etabliert, dokumentiert und bietet eine uniforme Lösung für die eigene Datenbereitstellung. Die Testdaten werden nur punktuell erzeugt und verwendet. Nur dort, wo sie als Parameter einer Testmethode angegeben sind, werden sie auch tatsächlich instanziiert. Außerdem können Variationen in den Testdaten über Annotationen direkt an den Parametern der Testmethoden konfiguriert werden.

Für alle, die neugierig geworden sind: einfach mal testen!

Test Fixtures mit JUnit 5

Senior IT Consultant

Bielefeld | Team

Vielen Dank für deine Anfrage. Ich melde mich bei dir.

Vielen Dank für deine Anmeldung. Eine E-Mail zur Bestätigung ist zu dir unterwegs.

Diese Seite ist eine Vorschau. \nKlicken Sie hier\n, um den Vorschaumodus zu verlassen.

Zu deiner Suche haben wir leider keine passenden Blogartikel gefunden. 

Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.

Du hast Fragen oder möchtest dich mit mir austauschen? Gern - trag einfach deine Kontaktdaten ein.

Die \nDatenschutzerklärung\n der codecentric AG habe ich zur Kenntnis genommen und bestätige das mit der Absendung des Formulars.*

Entdecke spannende weiterführende Themen und lass dich von der codecentric Welt inspirieren.

Ich möchte eure Inhalte abonnieren. Diese Einwilligung kann ich jederzeit widerrufen bzw. den Blog Newsletter abbestellen. Die Datenschutzerklärung habe ich gelesen. Ich bin damit einverstanden, dass die codecentric AG, Hochstr. 11, 42697 Solingen, mich über eigene Dienstleistungen, branchenrelevante Events, Webinare und Publikationen der codecentric AG über die von mir angegebene E-Mail-Adresse informiert. Meine Einwilligung ist freiwillig. Ich kann meine Einwilligung jederzeit mit Wirkung für die Zukunft widerrufen (z.B. über den hierfür vorgesehenen Abmeldelink in unserem Newsletter, per E-Mail an datenschutz@codecentric.de oder per Post an die oben genannte Adresse der codecentric AG) erklären. Weitere Hinweise zur Verarbeitung meiner personenbezogenen Daten und zu meinen Rechten als betroffene Person finde ich hier: \nhttps://www.codecentric.de/datenschutzerklaerung\n

Bitte wähle deine/n gewünschte/n Standort/e aus.

Wir möchten dich als Mensch kennenlernen. Erzähle uns, wer du bist, worauf du Wert legst, wie du gerne arbeitest und was du von uns als Arbeitgeber erwartest.

Bitte füge deine Bewerbungsunterlagen ​(mind. Lebenslauf, gerne auch mehr)​​ ​als eine ​PDF-​Datei ​hinzu.

Es gilt die Datenschutzerklärung der codecentric AG, abrufbar unter \nDatenschutzbestimmungen\n. Mit dem Absenden des Formulars bestätige ich, dass ich diese zur Kenntnis genommen habe.

Job application form field placeholder 10

Keine passende Rolle gefunden? Bewirb dich bitte trotzdem initiativ! Jenseits von starren Schubladen zählen für uns vielmehr Motivation, Kompetenz und der Cultural Fit.

Job application form field placeholder 11

Dies ist ein Pflichtfeld, bitte fülle es aus.

Willkommen im Team Bielefeld

Gemeinsam bessere Projekte umsetzen.

Wir helfen deinem Unternehmen.

Unsere Leistungen

Hilf uns, noch besser zu werden.

Zu den Jobangeboten