Cloud-Native

Data & KI

Produktentwicklung

Resilienz & 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

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.

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/mb8uoEqCT3G6iCQ9Chi8"><img src="https://media.graphassets.com/mb8uoEqCT3G6iCQ9Chi8" 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/L5rgQ3a6S1KhnYSmpgPM"><img loading="lazy" src="https://media.graphassets.com/L5rgQ3a6S1KhnYSmpgPM" 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/y5dzd5H3Qay63tNwHXQW"><img loading="lazy" src="https://media.graphassets.com/y5dzd5H3Qay63tNwHXQW" 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

Head of Industrial Solutions

<p>In diesem Artikel beschreiben wir die Entwicklung, zusammen mit den Herausforderungen, des Logstash-Java-Input-Plug-ins für Apache PLC4X, das im Rahmen des Open-Source-Projekts <em>Apache PLC4X</em> in Absprache mit Elastic entwickelt wurde.</p><h2>Architektonische Übersicht über das Logstash-Java-Input-Plug-in</h2><p>Zunächst werfen wir einen Blick auf die grundlegende Architektur und Systemlandschaft und werden im Anschluss die Umsetzung des Plug-ins betrachten. In der nachfolgenden Abbildung ist eine Übersicht über das Einsatzgebiet des Plug-ins zu sehen.</p><p><a href="https://media.graphassets.com/gxJl5zQzRpGyPUbS59zS"><img width="700" height="174" src="https://media.graphassets.com/gxJl5zQzRpGyPUbS59zS" alt="Overall architecture Logstash Java Input Plug-in PLC4X" /></a> </p><p>Wir verwenden im Plug-in das Framework Apache PLC4X, um Daten von IIoT-Geräten (Industrial Internet of Things) mittels Pull-Prinzip abzufragen. Diese Daten werden an Logstash übergeben, welches diese anschließend über ein Output-Plug-in der Pipeline mittels Push-Prinzip weiterleitet. Hier haben wir beispielsweise <em>ElasticSearch</em> gewählt.<br /> Neben der Abfrage von mehreren IIoT-Geräten in einer Pipeline ist es ebenfalls möglich, mehrere Pipelines zu definieren, um die Abfragen auf mehrere Pipelines zu verteilen. Dies ist z. B. bei verschiedenen Gerätetypen oder Standorten sinnvoll.</p><h2>Die Entwicklung des Plug-ins und der zugehörige Build-Prozess (als Teil von Apache PLC4X)</h2><p>Für die Entwicklung eines Logstash-Java-Input-Plug-ins gibt es von Elastic eine Anleitung, die <a href="https://www.elastic.co/guide/en/logstash/current/java-input-plugin.html" target="_blank">hier</a>  gefunden werden kann.<br /> Dort wird erklärt, dass als erstes der Quelltext von <em>logstash</em> heruntergeladen und gebaut werden muss. Anschließend wird im Projekt des Java-Logstash-Input-Plug-ins der Pfad zu <em>logstash</em> in der Datei <em>gradle.properties</em> eingetragen. Dieser Schritt ist notwendig, solange die entsprechende JAR-Datei von <em>logstash</em> noch nicht auf dem <em>Maven Central Repository</em> verfügbar ist. Aktuell ist noch unklar, wann dies der Fall ist – es existiert aber bereits ein <a href="https://github.com/elastic/logstash/issues/11002" target="_blank">Issue</a>  im entsprechenden GitHub-Projekt von Elastic.</p><p>Wird das Logstash-Java-Input-Plug-in anschließend gebaut, verwendet das Skript <em>gradle.build</em> die Datei <em>rubyUtils.gradle</em> von <em>logstash</em>. In diesen Utils wird JRuby heruntergeladen und anschließend verwendet. Für das Herunterladen und Entpacken von JRuby wird der Befehl <b><em>commandLine ‚./mvnw‘, ‚clean‘, ‚install‘, ‚-Pdist‘, ‚-Pcomplete‘</em></b> verwendet. Gradle führt Maven an dieser Stelle über einen Maven-Wrapper aus. Dies ist im Rahmen des Apache-PLC4X-Projekts ungünstig. Denn PLC4X verwendet Maven selbst als Build-Tool. Daher ergäbe sich bei einfacher Einbindung von Gradle aus der Elastic-Anleitung folgender Build-Prozess:</p><p><a href="https://media.graphassets.com/8AMEIWaPRhGC9O7fBQ97"><img loading="lazy" width="700" height="462" src="https://media.graphassets.com/8AMEIWaPRhGC9O7fBQ97" alt="Build process with maven and gradle (plc4x project)" /></a> </p><p>Hier ist eine unnötige Verkettung von Build-Tools zu sehen, da Maven Gradle ausführt und dieses im Anschluss wiederum Maven aufruft. Daher haben wir beschlossen, den Gradle-Teil des Build-Prozesses ebenfalls in Maven umzusetzen, sodass sich folgender Ablauf ergibt:</p><p><a href="https://media.graphassets.com/rmZ74i1Tki4RbXkfK3CA"><img loading="lazy" width="700" height="334" src="https://media.graphassets.com/rmZ74i1Tki4RbXkfK3CA" alt="build process with maven (plc4x project)" /></a> </p><p>Abschließend stellen wir noch die Umsetzung des Build-Prozesses mit Maven und den zugehörigen Plug-ins vor.</p><table><tbody><tr><td></td><td><a href="https://media.graphassets.com/qKQKQD9RHmU4U3XA4DDQ"><img loading="lazy" width="250" height="635" src="https://media.graphassets.com/qKQKQD9RHmU4U3XA4DDQ" alt="build process" /></a> </td></tr><tr><td><strong>groovy-maven-plugin:</strong> In diesem Schritt wird die Version ohne <em>SNAPSHOT</em> berechnet und als künstliche Eigenschaft in Maven (<em>current-full-version</em>) gesetzt. JRuby benötigt die Version in diesem Format, da es ansonsten mit einer Fehlermeldung abbricht.</td></tr><tr><td><strong>download-maven-plugin:</strong> Dieses Plug-in lädt und entpackt JRuby, das zum Erstellen des Artefakts benötigt wird.</td></tr><tr><td><strong>maven-resources-plugin:</strong> Dieses Plug-in bearbeitet alle Ressourcen (z. B. ersetze <em>${current-full-version}</em> durch die Version).</td></tr><tr><td><strong>maven-shade-plugin:</strong> Erstellt eine Fat JAR aus den Klassen und Dateien des Plug-ins sowie allen Abhängigkeiten.</td></tr><tr><td><strong>exec-maven-plugin:</strong> Mit diesem Plug-in werden JRuby und Gem aufgerufen, die anschließend das Artefakt <em>logstash-input-plc4x-X.X.X.gem</em> erstellen.</td></tr><tr><td><strong>build-helper-maven-plugin:</strong> Mit diesem Plug-in wird das Artefakt in Maven hinzugefügt, sodass es ebenfalls in der <em>install</em>-Phase von Maven berücksichtigt wird.</td></tr></tbody></table><h2>Beispielkonfiguration des Plug-ins</h2><p>Voraussetzung für die Verwendung des Plug-ins ist die Installation in Logstash. Anschließend kann das Plug-in wie folgt initialisiert und konfiguriert werden.<br /></p><div>

```autoconf
## logstash pipeline config - input
input {
	## use plc4x plugin (logstash-input-plc4x)
	plc4x {
		## define sources
		sources => {
			source1 => "opcua:tcp://opcua-server:4840/"
			source2 => "opcua:tcp://opcua-server1:4840/"
			source3 => "..."
		}
		## define jobs
		jobs => {
			job1 => {
				# pull rate in milliseconds 
				rate => 2
				# sources queried by job1
				sources => ["source1", ...]
				# defined queries [logstash_internal_fieldname => "IIoT query"]
				queries =>  {
					PreStage => "ns=2;i=3"
					MidStage => "ns=2;i=4"
					PostStage => "ns=2;i=5"
					Motor => "ns=2;i=6"
					ConvoyerBeltTimestamp => "ns=2;i=7"
					RobotArmTimestamp => "ns=2;i=8"
				}
			}
			job2 => { .... }
		}
	}
}
 
## logstash pipeline config - filter
filter {
	...
}
 
## logstash pipeline config - output
output {
	...
}
```

</div><p>Im Abschnitt <em>input</em> wird das Plug-in durch <em>plc4x</em> initialisiert. Innerhalb des <em>plc4x</em>-Abschnitts können <em>sources</em> und <em>jobs</em> definiert werden. <em>Sources</em> sind die Connection-Strings für die jeweiligen PLCs (hier beispielsweise OPC UA Server).<br /> Im <em>jobs</em>-Abschnitt können einzelne <em>jobs</em> definiert werden. Diese enthalten <em>queries</em> (Abfragen) für bestimmte <em>sources</em>. Die Abfragen sind in der Form <em>X => „Y“</em> angegeben. X ist der interne Feldname für Logstash. Y ist die Abfrage, die zum PLC gesendet wird.<br /> Für jeden Job wird eine Rate angegeben, die die Zeitspanne zwischen den einzelnen Abfragen definiert. Im Beispiel werden die fünf definierten Felder alle <em>300</em> Millisekunden von <em>source1</em> abgefragt.</p><h2>Quelltext des Java-Logstash-Plug-ins für PLC4X</h2><p>Das Plug-in besteht aus einer Klasse, die wir für diesen Blogbeitrag in drei Abschnitte aufgeteilt haben.</p><p>Im ersten Teil des Plug-ins werden die <em>sources</em> eingelesen und anschließend dem Builder des Scrapers von PLC4X hinzugefügt. Der Scraper ist ein Teil von PLC4X, um Daten regelmäßig von beliebigen PLCs abzufragen.</p><div>

```java
// parse sources
for (String sourceName : sources.keySet()) {
	Object o = sources.get(sourceName);
	if(o instanceof String) {
		String source = (String)o;
		builder.addSource(sourceName, source);
	} else {
		logger.severe("URL of source " + sourceName + "has the wrong typ!");
	}
}
```

</div><p>Der zweite Abschnitt des Quellcodes ist für das Einlesen und Erstellen der <em>jobs</em> zuständig.<br /> In der äußeren <em>for-</em>Schleife wird über alle definierten <em>jobs</em> iteriert. Für jeden einzelnen Job werden anschließend die Rate, die <em>sources</em> als auch die Abfragen eingelesen und dem <em>jobBuilder</em> (ebenfalls Teil des Scrapers) von PLC4X zugewiesen.</p><div>

```java
// parse jobs
for (String jobName : jobs.keySet()) {
	Object o = jobs.get(jobName);
	if (o instanceof  Map) {
		Map job = (Map<String, Object>) o;
		JobConfigurationTriggeredImplBuilder jobBuilder = builder.job(
			jobName, String.format("(SCHEDULED,%s)", job.get("rate")));
		for (String source : ((List<String>) job.get("sources"))) {
			jobBuilder.source(source);
		}
		Map<String, Object> queries = (Map<String, Object>) job.get("queries");
		for (String queryName : queries.keySet()) {
 
			String fieldAlias = queryName;
			String fieldAddress = (String) queries.get(queryName);
			jobBuilder.field(fieldAlias, fieldAddress);
		}
		jobBuilder.build();
	} else {
		logger.severe("Jobs of wrong Type!");
	}
}
```

</div><p>Nachdem nun alle <em>sources</em> und <em>jobs</em> eingelesen sind, können wir den Scraper ausführen. Bei der Initialisierung des Scrapers übergeben wir eine Lambda-Funktion, die nach erfolgreicher Abfrage der Felder aufgerufen wird. In dieser Funktion werden die erhaltenen Werte geloggt und die Ergebnisse anschließend vom <em>consumer</em> akzeptiert (der <em>consumer</em> ist Teil des Logstash-API und nimmt die Daten entgegen).</p><div>

```java
// start scraper
ScraperConfigurationTriggeredImpl scraperConfig = builder.build();
try {
	plcDriverManager = new PooledPlcDriverManager();
	triggerCollector = new TriggerCollectorImpl(plcDriverManager);
	scraper = new TriggeredScraperImpl(scraperConfig, (jobName, sourceName, results) -> {
		HashMap<String, Object> resultMap = new HashMap<String, Object>();
		resultMap.put("jobName", jobName);
		resultMap.put("sourceName", sourceName);
		resultMap.put("values", results);
 
		//TODO: add guard for debug mode, so only in debug mode its run
		for (Map.Entry<String, Object> result : results.entrySet()) {
			// Get field-name and -value from the results.
			String fieldName = result.getKey();
			Object fieldValue = result.getValue();
			logger.finest("fieldName: " + fieldName);
			logger.finest("fieldValue: " + fieldValue);
		}
		consumer.accept(resultMap);
	}, triggerCollector);
	scraper.start();
	triggerCollector.start();
} catch (ScraperException e) {
	logger.severe("Error starting the scraper: "+ e);
}
```

</div><h2>Fazit und Lessons Learned</h2><ul><li><b>Benennung von Dateien und Klassen</b><br /> Die Logstash-Java-Input-Plug-ins sind bei der Benennung der Dateien und Konfigurationen sehr sensitiv. Die Namen der Gemspec-, JAR- sowie Gem-Dateien müssen alle derselben Benennung folgen (z. B. <em>logstash-input-plc4x</em>). Ebenfalls müssen der Klassenname und einige Konfigurationen (beispielsweise Inhalte der Ruby-Konfiguration, also der <em>.rb</em>-Dateien) bezüglich der Benennung übereinstimmen. Zu Beginn der Entwicklung hatten wir uns überlegt, die <em>aritfact-id</em> des Projekts zu verwenden. Dabei hatten wir das Problem, dass wir diese nicht überall durch das <em>maven-resource-plugin</em> ersetzen lassen konnten. Dadurch stimmten die Benennungen teilweise nicht überein und es kam zu Problemen bei Installation und Ausführung des Plug-ins. Nachdem wir uns für eine statische Benennung des Plug-ins entschieden und alle relevanten Stellen identifiziert hatten, ließ sich das Plug-in in Logstash installieren und ausführen. Diese Lösung hat auch den Vorteil, dass die artifact-id <em>plc4j-logstash-plugin</em> mit dem Namensschema von PLC4X und der Plug-in Name <em>logstash-input-plc4x</em> mit dem Namensschema für Plug-ins in Logstash übereinstimmt.</li><li><b>Installationsdauer des Plug-ins</b><br /> Die Installation des Plug-ins in Logstash benötigt meist ~2 Minuten. Dies ist im Fehlerfall (wie z. B. bei der Problematik mit der Benennung) sehr unglücklich, da so zwischen Änderung und Test dieser einige Minuten vergehen.</li><li><b>Build-Tools: Maven, Gradle, JRuby, …</b><br /> Ein weiteres Learning dieses Projekts besteht darin, dass wir in zukünftigen Projekten die Verwendung mehrerer Build-Tools, genau wie hier, hinterfragen werden. Ansonsten entstehen gegebenenfalls ungünstige Verkettungen von Build-Tools wie oben beschrieben (Maven und Gradle). An dieser Stelle möchten wir uns auch bei <em>Christofer Dutz</em> bedanken, der uns bei dieser Problematik unterstützt hat.</li></ul><p>Der Quellcode des gesamten Plug-ins ist hier im PLC4X-Projekt zu finden.</p>

Logstash-Java-Input-Plug-in für Apache PLC4X

In diesem Artikel beschreiben wir gesammelte Best Practices für das Integration Testing von Microservices. Zu diesem Zweck haben wir ein Projekt namens <a href="https://github.com/codecentric/toti-example-service"  target="_blank">toti-example-service</a> erstellt und auf GitHub veröffentlicht. Wir werden uns in diesem Beitrag immer wieder auf dieses Projekt und auf den Quelltext beziehen.

## Kurzer Überblick über das Demo-Projekt
Das Projekt haben wir mit Kotlin und dem Spring-Boot-Framework erstellt. Es enthält beispielhaft zwei REST-Endpunkte, um die Interaktion mit einer Datenbank sowie einem anderen Microservice zu demonstrieren. Wie üblich bei Spring haben wir im Projekt verschiedene Schichten implementiert, wie Controller, Services, Repositories und Web-Clients.

Im Folgenden sind die Funktionalitäten der Beispielanwendung zu sehen:

![image.png](https://media.graphassets.com/ggaN8uPQBecJN41zL8VK)

Wie auf der Abbildung zu erkennen ist, wurde eine Funktionalität für Blogposts implementiert. Diese kann man in einer DynamoDB-Tabelle verwalten, und es steht eine einfache CRUD-API zur Verfügung.

Die zweite Funktionalität demonstriert die Kommunikation mit einem anderen Microservice. Hierbei ist es möglich, einen oder mehrere Fakten über Katzen (CatFacts) abzurufen. Diese werden im Hintergrund über einen WebClient von einer öffentlichen API abgefragt.

## Warum Integration Testing?
Wir stellen immer wieder fest, dass Integrationstests in Projekten zu wenig Beachtung finden und dementsprechend selten genutzt werden. Dabei hat sich gezeigt, dass sie einen großen Beitrag zur Sicherheit und Stabilität der Schnittstellen leisten können, da sie den Service als Black Box betrachten. Diese Sichtweise führt dazu, dass der Service aus der Sicht eines externen Systems getestet wird, was zur Verbesserung der Schnittstellen-Stabilität beiträgt.

Durch die Gewährleistung der Stabilität der Schnittstelle bieten Integrationstests bei Refactorings eine große Sicherheit, da der API-Vertrag garantiert unverändert bleibt. Dies erleichtert es, sowohl die interne Datenstruktur als auch die Implementierung eines Microservices zu ändern.

Im Projektalltag hat es sich mittlerweile etabliert, Fehler zunächst mit einem Integrationstest zu reproduzieren, bevor man sie behebt. Dadurch wird sichergestellt, dass der Fehler nicht erneut auftritt, und Sonderfälle sowie Ausnahmen sind im Quellcode dokumentiert – gegebenenfalls inklusive der Ticketnummer. Integrationstests helfen somit nicht nur bei der Stabilität der Software, sondern auch bei der Dokumentation von Ausnahmefällen.


## Was wir unter einem Integrationstest verstehen

Es kommt häufig vor, dass es Missverständnisse darüber gibt, was ein Integrationstest umfasst und was ihn ausmacht. Wir verstehen darunter einen Test, bei dem der Microservice unter möglichst realistischen Bedingungen getestet wird. Das bedeutet, dass der gesamte Quellcode, der auch in Produktion ausgeführt wird, getestet werden sollte – und auch ausschließlich dieser. Konkret bedeutet dies:

- Keine Beans überschreiben
- Keine Extra-Konfiguration, keine *TestConfiguration*
- keine Mocks des Quelltexts
- **echte Http-Aufrufe**
- **echte Persistenz in einer Datenbank** (z. B. PostgreSQL ausgeführt in Docker, …)


## Abgrenzung zu anderen Testarten
**Abgrenzung zu Unit-Tests:**
- Unit-Tests konzentrieren sich auf individuelle Komponenten, während Integrationstests die Zusammenarbeit zwischen Komponenten prüfen.
- Unit-Tests sind in der Regel schneller, da sie in Isolation ausgeführt werden, während Integrationstests mehr Zeit in Anspruch nehmen können, da sie die Interaktion zwischen Komponenten testen.

**Abgrenzung zu End-to-End-(E2E-)Tests:**
- E2E-Tests testen das gesamte System aus der Perspektive des Benutzers, während sich Integrationstests auf die Interaktionen zwischen Komponenten konzentrieren.
- E2E-Tests sind in der Regel langsamer als Integrationstests, da sie das gesamte System testen und oft komplexere Testumgebungen und -szenarien erfordern.


**Abgrenzung zu Performance-Tests:**
- Performance-Tests messen Leistungskennzahlen wie Antwortzeiten, Durchsatz und Ressourcenverbrauch, während Integrationstests die Funktionalität und Zusammenarbeit zwischen Komponenten testen.
- Performance-Tests haben den Fokus auf die Leistung und nicht auf die Funktionalität, während sich Integrationstests darauf konzentrieren, ob die Komponenten korrekt zusammenarbeiten.
## Wie sieht das in unserem Beispiel aus?

Um die zuvor genannten Anforderungen zu erfüllen, nutzen wir verschiedene Frameworks wie zum Beispiel <a href="https://wiremock.org/"  target="_blank">Wiremock</a>, <a href="https://greenmail-mail-test.github.io/greenmail/"  target="_blank">Greenmail SMTP Server</a>, <a href="https://www.testcontainers.org/modules/databases/postgres/"  target="_blank">Datenbanken in Docker</a> oder <a href="https://www.testcontainers.org/modules/localstack/"  target="_blank">AWS Localstack</a>. Auf diese Weise stellen wir sicher, dass die produktive Umgebung im Test möglichst genau nachgebildet wird. Konkret bedeutet dies:

![image.png](https://media.graphassets.com/ucGhioSqyN8puFwAVsCg)

In der Grafik wird deutlich, dass unser Microservice als Black Box betrachtet wird (grüne Box). Die Testumgebung wird möglichst realitätsnah nachgebildet, wie an den Boxen *Wiremock* und *Docker*(DynamoDb) zu erkennen ist. Der Test nutzt den HTTP-Server Wiremock und startet den Docker-Container, bevor die Testfälle ausgeführt werden. Anschließend ruft der Test unseren Microservice über die Rest-API auf, um beispielsweise Entitäten zu erstellen und abzurufen. Dies ist ein Beispiel für ein Integrationstest-Setup.

Hier eine Liste möglicher Frameworks zum Mocken des Microservice-Umfelds:
- Testcontainer: Postgres Dockerfile
- Testcontainer: Oracle Dockerfile
- Testcontainer: InfluxDb Dockerfile
- Testcontainer: Local DynamoDB Dockerfile
- Testcontainer: AWS Localstack (z. B. für SQS, SNS)
- Wiremock (leichtgewichtiger HTTP-Server, um andere Microservices zu mocken)
- GreenMail - SMTP Server Mock
- UnboundID LDAP Server Mock
- Eigene Extensions, um bspw. eine UDP Verbindung zu mocken


## Testcontainer am Beispiel DynamoDB als JUnit 5 Extension

Um das Testcontainer-Framework vor dem Start aller Tests zu initialisieren und hochzufahren, müssen die Daten für die Verbindung zum Container (Host, Port) in der Spring-Umgebung bekannt gemacht werden. Wir haben dabei gute Erfahrungen mit der Kapselung dieser Schritte in einer JUnit 5 Extension gemacht:

```kotlin

class DynamoDbLocalExtension : BeforeAllCallback {

    companion object {
        @JvmStatic
        var container = DynamoDbLocalContainer()

        @JvmStatic
        var initialized = false
    }

    override fun beforeAll(context: ExtensionContext) {
            if (!initialized) {
                container.withExposedPorts(8000)
                    .start()
                System.setProperty(
                    "dynamo.endpoint",
                     "http://${container.containerIpAddress}:${container.getMappedPort(port)}"
            )

                )

                createTables(context)
            }
    }

    private fun createTables(context: ExtensionContext) {
        val blogPostRepository = SpringExtension.getApplicationContext(context).getBean(BlogPostRepository::class.java)
        blogPostRepository.blogPostTable().createTable()
    }

    class DynamoDbLocalContainer : GenericContainer<DynamoDbLocalContainer>("amazon/dynamodb-local:latest")
}

```

Die JUnit 5 Extension erweitert den *BeforeAllCallback*, um sicherzustellen, dass die Initialisierung vor dem Hochfahren des Spring-Contexts stattfindet. Dabei werden die Konfigurationsparameter gesetzt und beim Hochfahren des Spring-Contexts dynamisch geladen.

Es ist jedoch zu beachten, dass die Methode *beforeAll* vor jeder Testklasse aufgerufen wird. Um sicherzustellen, dass der Container nur einmal initialisiert wird, verwenden wir die statische *initialized*-Property. Daher verzichten wir auch auf die automatisierte Verwaltung des Frameworks, die über die Annotation *@Container* gesteuert wird. Diese würde dazu führen, dass der Container nach jedem Test heruntergefahren wird.

## Performance-Überlegungen
In verschiedenen Projekten wurde argumentiert, dass das Starten mehrerer Docker-Container viele Ressourcen des Host-Systems verbraucht und daher nicht praktikabel ist. Heutzutage ist dies jedoch kein Problem mehr, da in der Regel alle Computer, insbesondere die von Entwicklern, mit ausreichenden Ressourcen ausgestattet sind. Im praktischen Betrieb ergeben sich in der Regel keine Probleme.

Sollte es dennoch zu Engpässen kommen, besteht die Möglichkeit,  <a href="https://www.testcontainers.cloud/"  target="_blank">Testcontainers in der Cloud von atomicjar</a>  zu verwenden.

Durch die Möglichkeit, alle Umgebungssysteme eines Services durch Container abzubilden, entsteht im Integrationstest eine zusätzliche Umgebung. So ist es unserer Meinung nach möglich, mit nur zwei Umgebungen (zum Beispiel Staging und Production) zu arbeiten und die Tests als Development-Umgebung zu betrachten.

## Beispiel für einen Integrationstest
Abschließend möchten wir ein kurzes Beispiel vorstellen, wie man einen Test konkret implementieren kann. Wir wollen hier die Schnittstelle zum Anlegen eines Blogposts ansprechen und testen, ob diese den Post korrekt anlegt und zurückgibt:

```kotlin

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ExtendWith(DynamoDbLocalExtension::class)
class BlogPostIntegrationTest {
    companion object {
        @JvmStatic
        @RegisterExtension
        val rest = WebTestClientExtention()
    }

    @Test
    internal fun `should create blog post and return it`() {
        val id = IdGenerator.nextAsLong()
        rest.webTestClient.put()
            .uri { uriBuilder ->
                uriBuilder.path("/blogposts/{id}")
                    .build(id)
            }.bodyValue(
                """
                {
                   "id": $id,
                   "title": "some title 2",
                   "content": "the content 2"
                }
            """.trimIndent()
            )
            .headers { headers -> headers.contentType = MediaType.APPLICATION_JSON }
            .exchange()
            .expectStatus().is2xxSuccessful
            .expectBody().json("""
                {
                   "id": $id,
                   "title": "some title 2",
                   "content": "the content 2"
                }
            """.trimIndent())
    }

}

```
In dem obigen Test Case wird deutlich, dass die zuvor angesprochene JUnit Extension mithilfe der *@ExtendWith*-Annotation verwendet wird, um sicherzustellen, dass die lokale DynamoDB vor dem Test hochgefahren und initialisiert wird. Anschließend rufen wir den Service über den *WebTestClient* von Spring Boot wie in einem externen System auf. In diesem Beispiel wird die Antwort nur auf das JSON-Dokument und den HTTP-Status geprüft, aber es könnten auch umfangreichere Validierungen durchgeführt werden. Ein bewährtes Framework für Validierungen ist beispielsweise <a href="https://assertj.github.io/doc/"  target="_blank">assertJ</a>, das sich hier gut einfügt.

**Takeaways:**
- Integrationstests sind wichtig für stabile und sichere Schnittstellen in Microservices.
- Der Test sollte den Service als Black Box betrachten und unter realistischen Bedingungen durchführen.
- Frameworks wie Wiremock, SMTP Server, Datenbanken in Docker oder AWS Localstack können ein praktikables Integrationstest-Setup bereitstellen.
- Die Abbildung aller Umgebungssysteme eines Services durch Container schafft im Integrationstest eine zusätzliche Umgebung.
- Parallelisierung von Integrationstests kann Testdauer verkürzen und Testabdeckung verbessern.
- Integrationstests sollten automatisiert in den Entwicklungsprozess durch Continuous Integration/Continuous Delivery integriert werden.
- Integrationstests geben ein gutes Gefühl, da die Schnittstellen nach außen garantiert funktionieren.


Wir bedanken uns für das Lesen dieses Beitrags und hoffen, einige Denkanstöße zum Thema Integration Testing gegeben zu haben. Wir werden diese Gedanken in weiteren Beiträgen vertiefen; der nächste wird sich mit dem Thema der Parallelisierung dieser Tests befassen.



Microservice Integration Testing done right 

IT Consultant and Software Engineer 

<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/7Cb1Fq98RWyGRMiUt3EB"><img width="700" height="249" src="https://media.graphassets.com/7Cb1Fq98RWyGRMiUt3EB" 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/GiyLH7n5SiuZrxZf6W8Z"><img loading="lazy" width="700" height="339" src="https://media.graphassets.com/GiyLH7n5SiuZrxZf6W8Z" 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. <a href="http://www.omg.org/soa/Uploaded%20Docs/EDA/bda2-2-06cc.pdf" target="_blank">[2]</a> </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/SVRd5slTpCWNDzdwuQCu"><img loading="lazy" width="700" height="852" src="https://media.graphassets.com/SVRd5slTpCWNDzdwuQCu" 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/1WClyWwMQwqeNRvoj3Kh"><img loading="lazy" width="700" height="500" src="https://media.graphassets.com/1WClyWwMQwqeNRvoj3Kh" 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 /> [2] <a href="http://www.omg.org/soa/Uploaded%20Docs/EDA/bda2-2-06cc.pdf" target="_blank">Event-Driven Architecture<br /> Overview – Event-Driven SOA Is Just Part of the EDA Story </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 /> 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/WkcCe4nMQqaCLf999TB4"><img width="916" height="439" src="https://media.graphassets.com/WkcCe4nMQqaCLf999TB4" 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>$$i = \pm p-z*{\sqrt{\frac{p*(1-p)}{n}}}$$</p><p>Wobei $p=\frac{1}{score}$, $n$ die Anzahl der Daten und $z$ 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/Famwj0m3RV25xqHFaqqn"><img loading="lazy" width="700" height="502" src="https://media.graphassets.com/Famwj0m3RV25xqHFaqqn" 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

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

<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/jYhyzTQRBmQbNDsOfuvO"><img src="https://media.graphassets.com/jYhyzTQRBmQbNDsOfuvO" 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/45oGyXmvThSIT0FF83iO"><img loading="lazy" src="https://media.graphassets.com/45oGyXmvThSIT0FF83iO" 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/AhYNLn5kRJ2fj6kT2nNx"><img loading="lazy" width="1024" height="307" src="https://media.graphassets.com/AhYNLn5kRJ2fj6kT2nNx" 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/1KHvYDE3SsSX14dJcwyQ"><img loading="lazy" src="https://media.graphassets.com/1KHvYDE3SsSX14dJcwyQ" 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/u0769PfSMusq7Piwmr6u"><img loading="lazy" width="1024" height="397" src="https://media.graphassets.com/u0769PfSMusq7Piwmr6u" 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><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/WkcCe4nMQqaCLf999TB4"><img width="916" height="439" src="https://media.graphassets.com/WkcCe4nMQqaCLf999TB4" 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>$$i = \pm p-z*{\sqrt{\frac{p*(1-p)}{n}}}$$</p><p>With $p=\frac{1}{score}$, $n$ is the number of data and $z$ 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/Famwj0m3RV25xqHFaqqn"><img loading="lazy" width="250" height="204" src="https://media.graphassets.com/Famwj0m3RV25xqHFaqqn" 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><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 /> $$Accuracy=frac{# correctly classified}{# all classifications}$$<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 /> $$Recall=frac{hit}{hit+miss}$$<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=frac{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 /> $$Precision=frac{hit}{hit+false alarm}$$<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=frac{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 /> $$F1=2*frac{Recall*Precision}{Recall+Precision}$$<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 (frac{1,0+0,1}{2}=0,55) – which intuitively does not do justice to the small value of precision. However, the harmonic mean is calculated to (frac{2*1,0*0,1}{1,0+0,1}=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 /> $$F_{beta}=(1+beta^2)*frac{Precision * Recall}{(beta^2*Precision)+Recall}$$<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/PhQkhSnqS1m6E61szB1k"><img width="250" height="177" src="https://media.graphassets.com/PhQkhSnqS1m6E61szB1k" 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/iweKTuAR4aZdJOS2neMA"><img loading="lazy" width="250" height="177" src="https://media.graphassets.com/iweKTuAR4aZdJOS2neMA" 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>$$MCC = frac{hit*miss-false alarm*correct reject}{sqrt{(hit+f.alarm)(hit+miss)(c.rej+f.alarm)(c.rej.+miss)}}$$</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 /> $$False Alarm Rate = frac{false alarm}{false alarm + correct reject}$$</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/MccEZUyfQF6bxr6X8fFo"><img loading="lazy" width="250" height="188" src="https://media.graphassets.com/MccEZUyfQF6bxr6X8fFo" 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 <a href="https://www.toyota-ti.ac.jp/Lab/Denshi/COIN/people/yutaka.sasaki/F-measure-YS-26Oct07.pdf" target="_blank">https://www.toyota-ti.ac.jp/Lab/Denshi/COIN/people/yutaka.sasaki/F-measure-YS-26Oct07.pdf</a> <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>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/chwiwqjHS4ao3hXJvPGj"><img src="https://media.graphassets.com/chwiwqjHS4ao3hXJvPGj" 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/7GzNghwQe2dAVC0X1eNM"><img loading="lazy" src="https://media.graphassets.com/7GzNghwQe2dAVC0X1eNM" 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/IRciGSDZSuOAyYWPt5GJ"><img loading="lazy" width="1024" height="307" src="https://media.graphassets.com/IRciGSDZSuOAyYWPt5GJ" 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/OCGb0Sk4TeWKSHCXsIeL"><img loading="lazy" src="https://media.graphassets.com/OCGb0Sk4TeWKSHCXsIeL" 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/jy29aZ76St2TBk0botsS"><img loading="lazy" width="1024" height="397" src="https://media.graphassets.com/jy29aZ76St2TBk0botsS" 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/BaZFDX7YRN2ZF8iQHoD3" alt="Beginn des Trainings" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/JrsiE2SSjaB9fWJEBGku" alt="Nach 200 gespielten Spielen" /><br /> <img loading="lazy" width="200" height="200" src="https://media.graphassets.com/eeb2Zlw3SuSQXrRqNUvA" alt="Nach 400 gespielten Spielen" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/oof9sf0QrC0T8hHoQyo6" 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/BaZFDX7YRN2ZF8iQHoD3" alt="Begin of the training" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/JrsiE2SSjaB9fWJEBGku" alt="After 200 played Games" /><br /> <img loading="lazy" width="200" height="200" src="https://media.graphassets.com/eeb2Zlw3SuSQXrRqNUvA" alt="After 400 played Games" /><img loading="lazy" width="200" height="200" src="https://media.graphassets.com/oof9sf0QrC0T8hHoQyo6" 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

<p>If you have ever created an application for a microcontroller such as the ESP32, you might have noticed that it’s quite different to most of the software development we as IT consultants are doing most of the time. Using C/C++ and ancient tooling for flashing and debugging always takes some time getting used to for me. The developers of Toit (see <a href="https://toit.io/" target="_blank">website</a> ) try to change this by introducing a programming language and associated tooling that support memory safety, over-the-air updates and fleet management for ESP32 devices.</p><h2>Why does it feel like it’s 1990 when developing software for embedded systems?</h2><p>As a software engineer, I am used to having a lot of tooling, quick development cycles and easy continuous deployment when working on projects. In the world of <a href="https://blog.codecentric.de/en/tag/iot/">IoT </a> and embedded computing, this doesn’t apply anymore in many cases. I have done a couple of small projects using ESP32 microcontrollers, which was nice, but I immediately noticed a couple of drawbacks that working with limited hardware has.</p><p>Most people try to squeeze the best possible performance out of the limited hardware. That is probably why the gold standard programming language that is used in these systems is C/C++, which can be a bit hard for beginners. Having a lot of control over the hardware also comes with a lot of control over stuff that can go wrong. I spent multiple days of searching for a bug once, which in the end just overwrote some memory <a href="https://github.com/florianluediger/WiFiDisplay/commit/214fdd33714dfc1b3bd6d96571a4370bc212fb66" target="_blank">because I hadn’t allocated enough of it</a> .</p><p>Flashing controllers like this can also be annoying because it’s typically done via a serial connection over USB. Over-the-air (OTA) updating is also possible, but it creates a whole new set of challenges, like for example a faulty OTA updater that overwrites memory of the main application. There also isn’t that much tooling for OTA updates and if you want to update over the internet you will probably have a bad time. If you want to have a fleet management solution like <a href="https://www.balena.io/" target="_blank">balena</a> , you are pretty much out of luck.</p><p>In theory, there are other languages than C/C++, like <a href="https://micropython.org/" target="_blank">MicroPython</a> , that can be used for easier development. Python, however, isn’t specifically designed for IoT usage, which means that it carries some baggage that hits its performance. MicroPython is a step in the right direction, but it doesn’t solve all the aforementioned problems.</p><h2>What is Toit and why do I like it so much?</h2><p>Toit (pronounced <a href="https://www.youtube.com/shorts/wdbiSDVU304" target="_blank">just like Jake Peralta would do</a> ) is a project by some former Google engineers that aims to improve the development experience when creating applications for microcontrollers. Currently, the project is under heavy development, which means that it’s not production-ready yet, and it only supports ESP32 chips right now. However, it’s worth taking a look at the components that Toit has to offer.</p><p><img width="1024" height="712" src="https://media.graphassets.com/Eer60CQHRq22YhDDgEqh" alt="Toit architecture overview" /></p><p>The Toit programming language is easy to learn and specifically designed to be used on embedded systems. It provides just the right features to be able to write IoT applications efficiently. The syntax takes a little time to get used to, but all in all, it’s pretty simple.</p><p>The bytecode that Toit compiles into is run on a virtual machine that is installed on the ESP32. This VM is able to schedule application executions, which for example allows an application to read data from a sensor every minute and stay in deep sleep the rest of the time. It will also ensure that different apps are isolated from each other and can’t read or write each other’s memory.</p><p>Because one of their main goals was improving the developers’ experience, the Toit developers offer a live reload server called <a href="https://github.com/toitlang/jaguar" target="_blank">Jaguar</a> . This is a small Toit application that runs on the controller and checks periodically if it received any updates for the Toit apps over the local network. This means that the developer’s computer doesn’t have to be connected to the ESP32 via cable anymore during development or to update the running applications to a new version.</p><p>There is also a cloud service that allows for further fleet management. On startup, devices will register at the service, which allows for checking the health of all active devices and services and also makes OTA updates over the internet possible. If you have ever used balena before, you might recognize this feature. However, the cloud service is currently deprecated because it’s based on an older version of Toit. The developers are working on a replacement, which will be open source, so you don’t have to rely on their proprietary service anymore.</p><h2>Great! What does all of this look like?</h2><p>To try this out, you can follow <a href="https://github.com/toitlang/jaguar#how-do-i-use-it" target="_blank">this tutorial</a> , which guides you through downloading the Jaguar toolkit and installing the Toit VM on your ESP32. I have created a small sample application that reads some values from an SCD30 sensor that is attached to the ESP32 via I²C. This code could be easily extended with functionality that publishes the sensor data via MQTT (<a href="https://github.com/florianluediger/scd30-to-mqtt-toit" target="_blank">see this example on GitHub</a> ).</p><div>

```java
import gpio
import i2c
import scd30
 
// The / symbol separates variable name and data type
// The construcor of scd30.Measurements is called with three arguments without parenthesis
measurements/scd30.Measurements := scd30.Measurements 0.0 0.0 0.0
 
// main: defines the entrypoint of the application
main:
  bus := i2c.Bus
    --sda=gpio.Pin 21   // Named parameter definitions are marked with --
    --scl=gpio.Pin 22
 
  device := bus.device scd30.Scd30.I2C_ADDRESS
  scd30 := scd30.Scd30 device
 
  while true:
    measurements = scd30.read
    print "co2: $measurements.co2, temperature: $measurements.temperature, humidity: $measurements.humidity"
    sleep --ms=5000
```

</div><p>This example basically just opens an I²C connection to the SCD30 sensor and prints the read values to the serial output. As I said, the syntax can be a little confusing because method parameters are just listed after the method name separated by spaces without parenthesis. Also, named parameters that are beginning with <code>--</code> can be written on a separate line. After understanding the basics, however, it’s a simple language where you don’t have to worry too much about deep control of your hardware.</p><p>After saving the code as <code>scd30.toit</code>, deploying the application over the local network onto your freshly flashed ESP32 is easy enough with the <code>jag run scd30.toit</code> command. If you want, you can also use <code>jag watch scd30.toit</code>, which will watch the local codebase and will automatically redeploy if any changes are detected. If you use the Toit cloud service, the serial output of the ESP32 will be displayed in your dashboard. Otherwise you would have to read it directly from the controller via USB and the <code>jag monitor</code> command.</p><h2>So, is Toit the next big thing for IoT?</h2><p>The ease of use and the fact that there is already a lot of great tooling in the Toit ecosystem makes it a great candidate for a language that is widely adopted in the IoT industry. The performance might not be as good as C/C++ code, but for most IoT applications this is not required, and development velocity has much higher value. However, Toit is still at its very beginning with a lot of construction going on, so I wouldn’t recommend it for production use just yet. I also had some issues finding specific things in the documentation because it’s not totally complete and sometimes contains deprecated information. I will definitely come back to Toit next year to see what has changed and I hope the language continues to grow and mature. If you like to play with microcontrollers and hardware, I highly recommend giving Toit a spin and taking part in the development process of the language through their <a href="https://github.com/toitlang/toit#community" target="_blank">Discord server</a> .</p>

Toit will bring your IoT projects up to speed

When your system contains many IoT devices that are scattered over a large production facility or even distributed over multiple facilities, it is important that you can manage and update the deployed software, access logs and easily provision new devices. 
This article describes and compares two popular technologies that can help you manage different features of your device fleet.

# Why do we need fleet management?

As soon as you design a system with a lot of devices, it is no longer feasible to manage each device individually by installing Linux on it and using SSH to access it.
In most IoT applications, many of the devices are very similar to each other, so you want to be able to execute operations and updates across many computers in parallel.
There are a couple of main use cases you will come across if you want to create an IoT system with multiple devices.

- You will need access to the device, which will allow you to read logs and restart your applications. This can already be problematic if the device is placed in a customer facility in a network that you can't access directly.
- An efficient DevOps strategy requires the ability to roll out automatic updates of your application throughout your whole fleet. Ideally, this includes having different environments for development, test and production.
- To ensure security, you need to be able to easily update the device operating system, installed packages or application dependencies.
- Provisioning of new devices should be as easy as possible, so you don't have to waste your time on installing Linux, installing packages, deploying your applications and so on for each device individually.

# What does balena do?

The <a href="https://www.balena.io/what-is-balena" target="_blank">balena environment</a> consists of the <a href="https://www.balena.io/os/" target="_blank">balena OS</a>, the <a href="https://www.balena.io/engine/" target="_blank">balena Docker engine</a>, a <a href="https://www.balena.io/cloud/" target="_blank">cloud service</a>, a <a href="https://www.balena.io/docs/reference/balena-cli/" target="_blank">CLI</a> for controlling the system and a <a href="https://dashboard.balena-cloud.com/" target="_blank">web dashboard</a>.
In most cases you will want to use all of these components as they work together very well.
The system is based on Docker containers that can be configured in a Docker compose format and that will be run by the balena Docker engine on the devices.
balena is free for 10 devices, and you will be <a href="https://www.balena.io/pricing/" target="_blank">charged on a per-device basis</a> if you have more devices in your fleet.

To use the system, you first need to flash balena OS onto one of their <a href="https://hub.balena.io/device-types" target="_blank">supported devices</a> and connect it to power and the internet.
The device will automatically connect to your account in the balena cloud and will be available for running your application containers.
Deploying an application to your device fleet can be done through the CLI with a simple `balena push` command.

The included dashboard is very useful for monitoring and administration of your fleet.
Here you can define groups and add devices to them.
You can also manage updates to your application releases and even the host OS version.
To configure your services, you can define environment variables, monitor the application status and check the container logs.
Additionally, you can also access the application containers and the host OS via SSH directly to fix errors or debug your software.

# What does Portainer do?

<a href="https://www.portainer.io/" target="_blank">Portainer</a> builds upon an existing container runtime that is running on your edge device already.
This is the main difference to the balena ecosystem which builds directly onto bare metal by supplying an operating system and the container engine as well.
Portainer installs a container running the <a href="https://github.com/portainer/agent" target="_blank">Portainer agent</a> on the device, which registers itself at the <a href="https://github.com/portainer/Portainer" target="_blank">cloud service</a> that is responsible for managing the whole fleet.
Portainer supports all devices that can run Docker or Kubernetes because the whole system is running inside of containers.
The community edition of Portainer is free and if you want some extra features or better support from Portainer, you will be <a href="https://www.portainer.io/pricing" target="_blank">charged on a per-device basis</a>, like with balena.
Because the Portainer agent runs in a container, you cannot access the host operating system from within Portainer.
If you need to, you can use another tool like <a href="https://goteleport.com/" target="_blank">Teleport</a> for this, which gives you direct SSH access, application tunneling and much more.

After your devices have connected to the Portainer cloud, you can deploy your services onto the device.
You can define your services in a Docker compose format or in a Kubernetes manifest, depending on which container engine is running on your devices.
Portainer can fetch the configuration from a Git repository automatically, which lets you update your service deployment automatically when committing to that repository.
There also is an HTTP API that you can use to deploy new application versions, from a CI pipeline for example.

The cloud dashboard gives you a lot of control over device groups and individual devices.
You can register new devices and sort them into groups that are used to categorize different deployments.
The interface also makes the access to the Docker engine very explicit as it gives you the option to directly use Docker features like containers, images, networks or volumes.
This way you can also look at application logs or connect directly to the containers.


# Comparison of both technologies

As you can see, these products use a slightly different approach to managing a fleet of devices.
balena supplies a combination of different tools, starting from the custom operating system, that make fleet management an easy task.
Portainer, on the other hand, builds upon an existing container runtime and focuses on giving you as much control over that as possible.

Portainer and balena will both support you when debugging your services because you will have access to the application status and logs.
You will also be able to access the service containers via SSH if you need to dig deeper.
However, only balena will give you access to the host OS because Portainer is not able to break out of the Portainer agent container.
This should rarely be necessary if your system is set up correctly.

You are able to define different fleets for different environments in both systems to be able to create a development cluster, for example.
To update these fleets, balena has a CLI that can be called from a CI pipeline so automatic updates are not a problem.
Portainer, on the other hand, provides an HTTP API that could be a little more difficult to use from within a CI pipeline, but it works as well.
Additionally, Portainer can monitor a Git repository for changes of its configuration and will update the fleet automatically.

balena makes it super easy to provision new devices because you can flash balena OS onto the device directly, and it will connect to the cloud automatically.
This way you will be able to easily set up a large number of devices and go productive very quickly.
Portainer can be a bit more tricky to set up because it is based on an existing Docker daemon running on the device already.
To save some time here, you can base your system on devices that already come with an OS and Docker preinstalled.
Alternatively, you can use <a href="https://www.ansible.com/" target="_blank">Ansible scripts</a> to set up multiple devices in parallel.
The fact that Portainer can be installed on any OS that is running Docker comes with the benefit that you will be able to integrate it into existing systems.
You can also install Portainer on devices where you can't change the preinstalled operating system at all, like the <a href="https://www.phoenixcontact.com/en-pc/industries/plcnext-technology" target="_blank">PLCNext industrial computer</a>, for example.

Because the balena OS that is running on the device is part of the whole infrastructure, you will be able to update it through the web UI.
You will see a warning that updating might break your production environment when something goes wrong, but if there are any security patches that you have to install, you will at least have the option.
Balena OS is also a very security-focused, limited operating system that is optimized for basically only running Docker on embedded devices.
Portainer does not make any restrictions for the operating system that is running on the devices, so you will have to pick one yourself.
You probably will want to choose something that is also very limited and security-focused, so you won't have to do updates too often.
Portainer will unfortunately not support you with operating system updates, so you will have to do that manually.

In my opinion, the UI of the balena dashboard is very easy to use and understand.
Some concepts from the underlying Docker system are abstracted in a sensible way, and many other nice features have been added that make managing your devices very convenient.
Portainers UI was a bit harder for me to understand, and the structure of the menus was not always clear to me.
However, the advantage here is that you have more direct control over the Docker system, so it will probably be easier to debug some Docker-related issues with your system.

# Conclusion

To conclude this breakdown of balena and Portainer in one sentence, I would say: 
If your hardware is supported, you only want to use the tool for IoT and you can pay the price for it, you should probably use balena.
The whole user experience is much better, deployments and device provisioning are easier, and you will gain access to the host operating system to update or dig deeper into debugging.
Portainer is a great alternative if you don't have the option to change the operating system of your devices, or they are not supported at all, as with PLCNext.
Because the community edition is free, Portainer will also be cheaper to operate than balena as long as you don't need any of the business edition features.
Portainer will also be more versatile if you want to use Kubernetes on your devices for example, or you also want to integrate your backend services in the same management software.

IoT fleet management: A comparison of balena and Portainer

IT Consultant

Senior Industrial Solutions Developer and Consultant

IT-Consultant / Machine Learning Engineer

<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

Werkstudent

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.

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.

Ich habe die \nDatenschutzbestimmungen\n und die Einwilligung in die Datenverarbeitung gelesen und stimme diesen zu.*

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.

Kontakt

Absenden

Willkommen im Team Bielefeld

Gemeinsam bessere Projekte umsetzen.

Wir helfen deinem Unternehmen.

Unsere Leistungen

Hilf uns, noch besser zu werden.

Zu den Jobangeboten