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

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

Cloud-Native

Data & Machine Learning

Generative KI

IT-Security

Produktentwicklung

Weitere Leistungen...

Leistungen

Arbeitsweise

Projekte

Berlin

Bielefeld

Dortmund

Erfurt

Frankfurt am Main

Hamburg

Karlsruhe

Leipzig

München

Münster

Nürnberg

Solingen

Stuttgart

Standorte

Blog

Softwerker

Fachmedien

Webinare

Events

Wissens-Hub

Unsere Kultur

Kultur & Karriere Podcast

Deine Entwicklung

Jobs

Karriere

Über uns

Aktuelles

Kontakt

Alle Standorte

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

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

Kontakt aufnehmen

Marketing & Community Management

Konntest du keine Einträge zu deinem Thema finden?  

STANDORT-TEAM

Lerne unser Team im Münster kennen

Unser codecentric Team am Standort Münster

codecentric Team Münster

Willkommen im Team Münster

<p>Am 21. und 22. Mai hatte ich die Ehre, an der rOpenSci Unkonferenz in Seattle teilnehmen zu dürfen. Es war ein großartiges Event, bei dem ich viele tolle Menschen kennenlernen konnte. Hier berichte ich über das Event und das Projekt, an dem ich dort gearbeitet habe: TensorFlow Probability in R & das „greta“-Paket.</p><h1>rOpenSci</h1><p><a href="https://ropensci.org/" target="_blank">rOpenSci</a>  ist eine gemeinnützige Organisation, die eine Reihe von <a href="https://ropensci.org/packages/" target="_blank">R-Paketen</a>  verwaltet und sehr aktiv den <a href="https://ropensci.org/community/" target="_blank">Gemeinschaftsgeist</a>  rund um die R-Welt fördert. Ihre zentralen Werte sind offene und reproduzierbare Forschung, Daten offen zugänglich zu machen, einfach zu bedienende Tools für Datenanalysen zu schaffen und all dies einer großen Anzahl an Menschen zugänglich zu machen.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/CklmaK8lRxOpNOWsVYI1"><img width="250" height="99" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/CklmaK8lRxOpNOWsVYI1" alt="Seattle, WA" /></a> </p><h1>rOpenSci Unkonferenz</h1><p>Die jährliche Unkonferenz trägt dazu bei, eine welt- und diversitätsoffene Infrastruktur für die Community zu schaffen. Bei der Konferenz treffen etwa 60 eingeladene Gäste aus der ganzen Welt zusammen, um an kleinen Projekten zu arbeiten, die derzeit für die R-Community relevant sind. Ideen für Projekte werden in den Wochen vor der Unkonferenz auf GitHub gesammelt und diskutiert, aber die endgültige Entscheidung, an welchen Projekten gearbeitet wird, wird von den Teilnehmern am ersten Morgen der Unkonferenz getroffen.</p><p><a href="http://unconf18.ropensci.org/" target="_blank">Die diesjährige rOpenSci Unkonferenz</a>  fand im Microsoft-Reactor in Seattle statt.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/03FGEBAxSHCfkXxGgwN6"><img loading="lazy" width="250" height="139" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/03FGEBAxSHCfkXxGgwN6" alt="Microsoft Reactor" /></a> </p><p>Das gesamte Organisationsteam – allen voran Stefanie Butland – hat diese Veranstaltung hervorragend organisiert. Die gesamte Gruppe trug dazu bei, dass der Spirit der Unkonferenz für alle von Anfang an sehr offen und inklusiv war, von den Alteingesessenen bis hin zu Neulingen.</p><p>Wir waren eine ziemlich heterogene Gruppe von Sozialwissenschaftlern, Bioinformatikern, Ökologen, Historikern, Data Scientisten, Entwicklern, Mitarbeitern von Google, Microsoft und RStudio sowie R-Enthusiasten aus vielen anderen Bereichen. Einige Leute kannten sich bereits, viele kannten sich von Twitter, den R-Ladies oder anderen Online-Communities, aber die meisten von uns (einschließlich mir) hatten sich noch nie persönlich getroffen. Deshalb wurde der offizielle Teil der Unkonferenz am Montagmorgen mit einigen „Eisbrechern“ begonnen: Stefanie stellte eine Frage oder machte eine Aussage und wir positionierten uns entsprechend unserer Antwort im Raum und diskutierten mit den umstehenden Menschen. Beginnend mit „Seid ihr ein Hunde- oder Katzenmensch?“ und abschließend mit „Ich kenne meinen Platz in der R-Community“, hatten wir alle schnell viel zu diskutieren – eine großartige Möglichkeit, viele der Leute kennenzulernen, mit denen wir die nächsten zwei Tage verbringen würden!</p><p>Es war toll, mit so vielen talentierten und motivierten Menschen zusammenzuarbeiten, die meine Leidenschaft für die Sprache R teilen – besonders weil sich die Mehrheit der aktiven R-Community im pazifischen Nordwesten und in Kalifornien befindet. Es war eine ganz neue Erfahrung, mit anderen Leuten an einem R-Projekt zusammenzuarbeiten und ich war mehr als begeistert!</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/XbjXDx6VTtWHhmZ6CFQ4"><img loading="lazy" width="250" height="188" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/XbjXDx6VTtWHhmZ6CFQ4" alt="rOpenSci Unkonferenz Projektarbeit" /></a> </p><h1>Unser TensorFlow Probability / greta-Projekt</h1><p>Während der 2-tägigen Unkonferenz wurde an vielen interessanten, nützlichen und coolen Projekten gearbeitet: <a href="https://github.com/ropenscilabs/runconf18-projects/blob/master/index.Rmd" target="_blank">hier ist die komplette Liste mit Links zu den einzelnen Projekten auf GitHub.</a> )</p><p>Die Gruppe, der ich beigetreten bin, wollte ursprünglich TensorFlow Probability in R integrieren.</p><blockquote><p>TensorFlow Probability is a library for probabilistic reasoning and statistical analysis in TensorFlow. As part of the TensorFlow ecosystem, TensorFlow Probability provides integration of probabilistic methods with deep networks, gradient-based inference via automatic differentiation, and scalability to large datasets and models via hardware acceleration (e.g., GPUs) and distributed computation.<br /> https://github.com/tensorflow/probability</p></blockquote><p>Letztendlich haben wir – das waren Michael Quinn, David Smith, Tiphaine Martin, Matt Mulvahill und ich – mit dem R-Paket <a href="https://github.com/greta-dev/greta" target="_blank">greta</a>  gearbeitet, das ähnliche Funktionalitäten wie TensorFlow Probability bietet. Wir haben einige der <a href="https://github.com/ropenscilabs/greta/blob/unconf/README.md" target="_blank">Beispiele aus den Tutorials der TensorFlow Probability Bibliothek in greta erstellt und einige zusätzliche Beispiele entwickelt</a> , die zeigen, wie man greta verwenden kann.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/jtuhWlJGSrFDwZWScLk6"><img loading="lazy" width="250" height="140" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/jtuhWlJGSrFDwZWScLk6" alt="rOpenSci Unkonferenz Projektvorstellung" /></a> </p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/B4HbRwJ7SFilhXYRR47I"><img loading="lazy" width="250" height="188" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/B4HbRwJ7SFilhXYRR47I" alt="rOpenSci Unkonferenz Projektarbeit" /></a> </p><h1>Was ist greta?</h1><p>greta ist ein R-Paket, das von Nick Golding für die Implementierung von Markov-Chain-Monte-Carlo-(MCMC-)Modellen, z. B. Hamiltonian Monte Carlo (HMC), entwickelt wurde. Es bietet eine Reihe von Funktionen, die das Definieren dieser Modelle erleichtern, insbesondere für Bayesian-Statistiken (ähnlich wie Stan).</p><blockquote><p>greta lets us build statistical models interactively in R, and then sample from them by MCMC.<br /> https://greta-dev.github.io/greta/get_started.html#how_greta_works</p></blockquote><p>Googles TensorFlow wird als Backend zur Berechnung der definierten Modelle verwendet. Da TensorFlow für große Modelle optimiert wurde und auch Multi-Core- und GPU-Berechnungen unterstützt, ist greta besonders effizient und nützlich für die Arbeit mit komplexen Modellen. Da TensorFlow ursprünglich kein R-Paket ist, verwendet greta die <a href="https://rstudio.github.io/reticulate/articles/python_packages.html" target="_blank">reticulate</a>  und <a href="https://tensorflow.rstudio.com/" target="_blank">tensorflow</a>  Pakete von RStudio, um eine Verbindung mit dem TensorFlow-Backend herzustellen. Auf diese Weise können wir mit allen TensorFlow-Funktionen direkt von R aus arbeiten.</p><h2>Wie funktioniert greta?</h2><p>Dies ist das minimale Arbeitsbeispiel des linear gemischten Modells, das wir mit greta entwickelt haben und auf einem Beispiel eines TensorFlow Probability Jupyter Notebooks basiert. Das vollständige Beispiel mit Erklärungen ist <a href="https://github.com/ropenscilabs/greta/blob/unconf/vignettes/8_schools_example_model.Rmd" target="_blank">hier</a>  zu finden.</p><p><code> library(greta)</code></p><p># data<br /> N <- letters[1:8]<br /> treatment_effects <- c(28.39, 7.94, -2.75 , 6.82, -0.64, 0.63, 18.01, 12.16)<br /> treatment_stddevs <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)</p><p># variables and priors<br /> avg_effect <- normal(mean = 0, sd = 10)<br /> avg_stddev <- normal(5, 1)<br /> school_effects_standard <- normal(0, 1, dim = length(N))<br /> school_effects <- avg_effect + exp(avg_stddev) * school_effects_standard</p><p># likelihood<br /> distribution(treatment_effects) <- normal(school_effects, treatment_stddevs)</p><p># defining the hierarchical model<br /> m <- model(avg_effect, avg_stddev, school_effects_standard)</p><p>## greta model<br /> plot(m)<br /> </p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/wahbkuyZQOyc8xGRIoLw"><img loading="lazy" width="250" height="84" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/wahbkuyZQOyc8xGRIoLw" alt /></a> </p><p>Der Haupttyp von Objekten, mit denen in greta gearbeitet wird, ist der greta Array. Man kann greta Arrays neu erstellen oder andere R-Objekte, wie Data Frames, in greta Arrays konvertieren. greta Arrays sind im Grunde eine Liste mit einem Element: ein R6-Klassen-Objekt mit einem Knoten + Daten, Operationen oder Variablen. Auf diese Weise nutzt greta die graphenbasierte Organisation der Modellierung. Jeder Knoten in unserem Modellgraphen stammt von einem greta Array und verbindet somit Knoten, Variablen, Daten und Operationen, um einen gerichteten azyklischen Graphen (DAG) zu erzeugen, der das Modell definiert, wenn die model() Funktion aufgerufen wird.</p><h1>TensorFlow Probability</h1><p>TensorFlow Probability ist kein Teil des TensorFlow-Kernpakets, weshalb wir das tensorflow-R-Paket nicht nutzen konnten. Stattdessen haben wir jedoch das reticulate-Paket genutzt, um Python-Module (alias Bibliotheken) in R zu importieren und dort zu benutzen. Auf diese Weise konnten wir die ursprünglichen Funktionen aus der tensorflow_probability Python-Bibliothek in R verwenden.<br /> Zum Beispiel konnten wir so mit den Edward2-Funktionalitäten von TensorFlow Probability arbeiten.</p><blockquote><p>Edward is a Python library for probabilistic modeling, inference, and criticism. It is a testbed for fast experimentation and research with probabilistic models, ranging from classical hierarchical models on small data sets to complex deep probabilistic models on large data sets. Edward fuses three fields: Bayesian statistics and machine learning, deep learning, and probabilistic programming. […] Edward is built on TensorFlow. It enables features such as computational graphs, distributed training, CPU/GPU integration, automatic differentiation, and visualization with TensorBoard. http://edwardlib.org/</p></blockquote><h2>Dankesworte am Schluss</h2><p>Ein großes Dankeschön geht an mein tolles greta-Team und an rOpenSci – insbesondere an Stefanie Butland – für die Organisation eines so wunderbaren Events!<br /> Ebenfalls geht ein großes Danke an alle Sponsoren, die es mir ermöglicht haben, in den pazifischen Nordwesten zu fliegen und an der Unkonferenz teilzunehmen!</p><blockquote><p>A sincere thank you to all participants in <a href="https://twitter.com/hashtag/runconf18?src=hash&ref_src=twsrc%5Etfw">#runconf18</a> </p><p>This thread?includes links to all project repos: <a href="https://t.co/2PhAz4zSuK">https://t.co/2PhAz4zSuK</a> <a href="https://twitter.com/hashtag/rstats?src=hash&ref_src=twsrc%5Etfw">#rstats</a>  <a href="https://t.co/8SICcWkQ0v">pic.twitter.com/8SICcWkQ0v</a> </p><p>— rOpenSci (@rOpenSci) <a href="https://twitter.com/rOpenSci/status/1000024996876468224?ref_src=twsrc%5Etfw">May 25, 2018</a> </p></blockquote><p></p><p>—</p><p>Dieser Artikel ist im Original auf meinem <a href="https://shirinsplayground.netlify.com/2018/05/ropensci_unconf18/" target="_blank">privaten Blog</a>  erschienen.</p>

rOpenSci Unkonferenz 2018 und eine Einführung in TensorFlow Probability & das „greta“-Paket

<p>Computer haben angefangen mit uns zu reden! Dahinter stecken sogenannte Text-to-Speech-(TTS-)Systeme. Durch neuronale Netze, Deep Learning und viele Trainingsdaten sind die in den letzten Jahren immer besser und besser geworden. In manchen Fällen kann man sogar kaum noch zwischen Mensch und Maschine unterscheiden.</p><p>In einem unserer neuesten <a href="/wissens-hub/blog/kuenstliche-intelligenz-codecentric_ai/">codecentric.AI</a>  <a href="https://www.youtube.com/c/codecentricAI" target="_blank">Videos</a>  haben wir euch einen <a href="https://youtu.be/2EEMSsVBE8w" target="_blank">Vergleich von Text-to-Speech-Systemen</a>  gezeigt: Wir haben einen kleinen Wettbewerb zwischen Polly, Alexa, Siri und Co mit verschiedenen Zungenbrechern veranstaltet und geguckt, was diese Systeme so alles können. Um uns anzuhören, wie die verschiedenen Systeme klingen, haben wir deutsche und englische Stimmen verglichen und auch selber ein paar Zungenbrecher aufgesagt.</p><div><div><div> <img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/1si3XtMbRf6eDCXwcL1o" alt="YouTube" /><div><p>Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.<br /><a href="https://policies.google.com/privacy" target="_blank">Mehr erfahren</a> <br /></p><p><a href="#">Video laden</a> </p><p> <small>YouTube immer entsperren</small></p></div></div></div><div></div></div><p>Übrigens: Wer diesen Artikel lieber hören statt lesen möchte, findet hier die <a href="https://soundcloud.com/shirin-glander-729692416/tongue-twister-blogpost/s-GoXFt" target="_blank">Audioversion – natürlich powered by TTS AI (Amazon Polly)</a> !</p><div><h2>Text-to-Speech-Systeme</h2><p>Text-to-Speech (TTS) bezeichnet Systeme oder Applikationen, die geschriebenen Text als Input nehmen und in gesprochene Audioversionen umwandeln; sie lesen uns also digitalen Text laut vor. Der computergenerierte akustische Output soll dabei möglichst menschlich und “echt” klingen. Mithilfe von neuronalen Netzen und Deep Learning sind TTS Systeme dabei in den vergangenen Jahren deutlich besser geworden. Heute gibt es Modelle, die schon sehr natürlich klingen und teilweise kaum noch von einem Menschen zu unterscheiden sind.</p><p>TTS-Systeme finden in vielen Programmen Anwendung; die bekanntesten sind sicherlich persönliche Assistenten wie Siri, Alexa, Cortana und Google. Aber auch in “kleineren” Programmen findet sich TTS-Technologie! So hilft TTS zum Beispiel Sehbehinderten dabei, mit Computern, Tablets, Smartphones oder anderen digitalen Geräten arbeiten zu können. TTS kann auch mit anderen Techniken aus der Spracherkennung kombiniert werden, wie zum Beispiel Optical Character Recognition (OCR), um Text auf Bildern zu lesen oder Voice Recognition, um gesprochenen Input zu verstehen und darauf zu antworten. Wir können uns Nachrichten, Bücher oder Artikel vorlesen lassen, während wir z.B. Auto fahren oder Programme über Sprachanweisungen steuern ohne die Hände nutzen zu müssen.</p></div><div><h2>Wie funktioniert TTS?</h2><p>Herausforderungen für gute TTS-Systeme sind die Komplexität der menschlichen Sprache: je nachdem wie wir einen Satz betonen, kann er unterschiedliche Bedeutungen haben. AI-basierte TTS Systeme berücksichtigen Phoneme und Satzmelodie. Es gibt mehrere Ansätze für die künstliche Erzeugung von Sprache.</p><p>Eine der wichtigsten ist die Unit-Selection-Synthese. Hierbei wird der Text zunächst normalisiert und in kleine Einheiten aufgeteilt; das können Sätze, Wörter, Silben, Phoneme etc. sein. Die Strukturen (z. B. die Aussprache) dieser Einheiten werden im Kontext gelernt. Dieser Teil fällt unter das sogenannte Natural Language Processing (NLP). Außerdem wird eine Sprachdatenbank generiert, die basierend auf dem segmentierten Text durchsucht wird, um passende Sprachbausteine zu finden (Unit Selection). Diese Suche passiert heutzutage in der Regel mit Entscheidungsbäumen, Neuronalen Netzen oder Hidden-Markov-Modellen. Die Sprachdatenbank selber kann aus menschengesprochenen Audiostücken bestehen oder die entsprechenden Phoneme werden von einem Computer generiert. Letzteres nennen wir Formantensynthese. Sie bietet deutlich mehr Möglichkeiten, denn der Sprachschatz ist nicht limiert; auch jedes unbekannte Wort kann vom Computer generiert werden und die Stimmen können flexibel ausgetauscht werden. Bis vor Kurzem klang aus menschengesprochenen Bausteinen synthetisierte Sprache noch deutlich besser als aus der Formantensynthese. Aber das ändert sich gerade deutlich und es gibt schon viele “künstliche” TTS-Systeme, die sehr menschlich klingen.</p></div><div><h2>Welche TTS-Systeme gibt es?</h2><p>Alexa hat sich weltweit millionenfach verkauft. Dein Google Navi erzählt dir, wo du abbiegen musst. Siri erinnert dich an deine Termine. Cortana gibt dir Windows-Tipps. Watson beantwortet Support-Anfragen usw. Aber es gibt auch eine Reihe von webbasierten Programmen oder Handy-Apps, die einen eingegebenen Text vorlesen.</p><p>In vielen digitalen Geräten gibt es schon eingebaute TTS-Systeme, z. B. in Computern, Smartphones, usw.</p><ul><li>Microsoft/Windows: besitzt das eingebaute TTS-System <a href="https://support.microsoft.com/de-de/help/22798/windows-10-narrator-get-started" target="_blank"><strong>Narrator</strong></a>  und die <a href="https://www.microsoft.com/en-us/download/details.aspx?id=10121" target="_blank"><strong>Microsoft Speech API</strong></a> </li><li>Mac: hat <a href="https://www.apple.com/de/accessibility/mac/vision/" target="_blank"><strong>VoiceOver</strong></a>  (oder auf älteren Rechnern <strong>PlainTalk</strong>)</li><li>Linux: verschiedene TTS Programme können installiert werden, z.B. <a href="https://sourceforge.net/projects/espeak/files/espeak/"><strong>eSpeak</strong></a> </li></ul><p>Viele TTS-Systeme gibt es als Software zum Herunterladen und Installieren und/oder webbasiert im Browser bzw. als API. Die großen Cloud-Anbieter wie Amazon, Google, IBM und Microsoft bieten TTS-Systeme “as a Service” an, so dass man mit wenig Aufwand Sprachausgabe in seine eigenen Programme integrieren kann. Aber es existieren auch einige Open-Source-Projekte für TTS (allerdings sind die meistens nur für Windows verfügbar). Hier eine unvollständige Liste von Systemen:</p><ul><li><a href="https://www.ibm.com/watson/services/text-to-speech/" target="_blank">IBM Watson</a> </li><li><a href="https://cloud.google.com/text-to-speech/" target="_blank">Google Cloud</a> </li><li><a href="https://azure.microsoft.com/de-de/services/cognitive-services/speech/" target="_blank">Microsoft Azure</a> </li><li><a href="https://developer.amazon.com/de/alexa" target="_blank">Amazon Alexa</a> </li><li><a href="https://9to5mac.com/2017/03/10/how-to-get-siri-to-read-articles-to-you-on-ios-macos/" target="_blank">Siri on iPhone</a> </li><li><a href="https://aws.amazon.com/de/polly/" target="_blank">Polly on Amazon AWS</a> </li><li><a href="https://support.microsoft.com/de-de/help/17214/windows-10-what-is" target="_blank">Microsoft Cortana</a> </li><li><a href="https://freetts.sourceforge.io/docs/" target="_blank">FreeTTS</a> </li><li><a href="https://www.ispeech.org/text.to.speech" target="_blank">iSpeech</a> </li><li><a href="https://www.naturalreaders.com/online/" target="_blank">Natural Readers</a> </li><li><a href="http://www.cross-plus-a.com/balabolka.htm" target="_blank">Balabolka</a> </li><li><a href="https://www.panopreter.com/en/products/pb/download.php" target="_blank">Panopreter</a> </li><li><a href="https://www.text2speech.org/" target="_blank">text2speech.org</a> </li><li><a href="http://text-to-speech-translator.paralink.com/" target="_blank">text-to-speech-translator.paralink.com/</a> </li></ul></div><h2>Text-to-Speech von der Kommandozeile aus</h2><p>Mit <a href="http://espeak.sourceforge.net/" target="_blank">espeak</a>  können wir auch direkt von der Kommandozeile aus TTS generieren:</p>

```hljs
espeak -v german -w 'tongue_twister_intro2.wav' 'Computer haben angefangen mit uns zu reden! Dahinter stecken sogenannte Text-to-Speech (TTS) Systeme. Durch neuronale Netze, Deep Learning und viele Trainingsdaten sind die in den letzten Jahren immer besser und besser geworden. In manchen Fällen kann man sogar kaum noch zwischen Mensch und Maschine unterscheiden.'
```

<p>Das Ergebnis hört ihr <a href="https://soundcloud.com/shirin-glander-729692416/tongue-twister-intro-2/s-a0xer" target="_blank">hier</a> .</p><h2>Text-to-Speech in Python</h2><p>Auch mit <a href="https://www.geeksforgeeks.org/convert-text-speech-python/">Python</a>  kann man schnell und einfach TTS erzeugen, z. B. mit dem <strong>gTTS</strong>-Paket, das die Google Text-to-Speech (TTS) API nutzt:</p>

```hljs
# Python3
pip install gTTS
```



```hljs
# Python3
from gtts import gTTS
import os
 
# Text
mytext = 'Computer haben angefangen, mit uns zu reden! Dahinter stecken sogenannte Text-to-Speech-(TTS-)Systeme. Durch neuronale Netze, Deep Learning und viele Trainingsdaten sind die in den letzten Jahren immer besser und besser geworden. In manchen Fällen kann man sogar kaum noch zwischen Mensch und Maschine unterscheiden.'
 
# Sprache (ISO Code)
language = 'de'
 
# Erzeugen der Sprachausgabe
myobj = gTTS(text=mytext, lang=language, slow=False)
 
# Speichern als mp3
myobj.save("tongue_twister_intro.mp3")
```

<p>Das Ergebnis hört ihr <a href="https://soundcloud.com/shirin-glander-729692416/tongue-twister-intro/s-wm9um">hier</a> .</p><div><h2>Wer spricht am besten?</h2><p>Mit der Vielzahl an (frei verfügbaren) TTS Systemen ist es inzwischen sehr leicht, TTS in eigene Programme oder Apps einzubauen. Ein paar Beispiele habt ihr hier kennengelernt. In unserem <a href="https://youtu.be/2EEMSsVBE8w">Video</a>  und in der <a href="https://soundcloud.com/shirin-glander-729692416/tongue-twister-blogpost/s-GoXFt" target="_blank">Audioversion</a>  von diesem Blogpost konntet ihr verschiedene TTS-Systeme im Vergleich hören. Im Moment klingen die englischen Stimmen meist noch deutlich besser als die deutschen. Die deutschen Stimmen klingen bei den meisten Anbietern noch ziemlich blechern. Auch ist es noch problematisch, wenn z. B. englische Ausdrücke in einem deutschen Text vorkommen, wie in der vorgelesenen Versionen dieses Artikels deutlich zu hören ist; da wir uns nur für eine Sprache entscheiden können, wird in der deutschen Variante auch englischer Text von den TTS-Systemen sehr “deutsch” ausgesprochen. Aber wie wir im <a href="https://youtu.be/2EEMSsVBE8w" target="_blank">Video</a>  gehört haben, gibt es bereits ein paar Modelle, die deutlich besser klingen als andere. Es ist nur noch eine Frage der Zeit, bis diese für alle Services einsatzbereit sind.</p></div>

Vergleich von Text-to-Speech-Systemen

<p>Im April 2018 haben wir bei codecentric eine AI (Artificial Intelligence bzw. KI = künstliche Intelligenz) Initiative gestartet. Unter dem Projektnamen „<a href="/leistungen/data-science-und-kuenstliche-intelligenz">codecentric.AI</a> “ werden wir versuchen zu zeigen, was heute mit künstlicher Intelligenz möglich ist (und was nicht). Man hört und liest überall von neuronalen Netzen, NLP, Computer Vision, CNNs, RNNs, LSTMs, AI, KI, Deep Learning und vielen weiteren Buzzwords.<br /> Wir werden die aktuellsten Technologien ausprobieren und darüber berichten, Tutorials veröffentlichen, interessante Paper vorstellen und in Demos zeigen, welche neuen Möglichkeiten sich durch Deep Learning & Co. KG ergeben.</p><p><img width="800" height="392" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/OvtVGy9ARwu6QbUB1Rnt" alt="Banner künstliche Intelligenz" /></p><p>Um diese Themen richtig darstellen zu können, haben wir einen speziellen <a href="https://www.youtube.com/channel/UC_r-M-0JQZUnOG2gJSL9pfg" target="_blank">YouTube-Kanal</a>  eingerichtet. Dort werden wir nur Videos zum Thema „AI“ einstellen. Hier siehst du ein erstes Beispiel zum Thema Object Detection. Wir fliegen mit einer Drohne durch unser Headquarters in Solingen und lassen Detectron (ein neuronales Netz von Facebook) Objekte detektieren:</p><div><div><div><div> <img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/8LnnvnWTQir5XNkscjGQ" alt="YouTube" /><div><p>Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.<br /><a href="https://policies.google.com/privacy" target="_blank">Mehr erfahren</a> <br /></p><p><a href="#">Video laden</a> </p><p> <small>YouTube immer entsperren</small></p></div></div></div><div></div></div></div><p>Wenn dir das Video gefallen hat und/oder wenn dich das Themengebiet interessiert, kannst du unseren <a href="https://www.youtube.com/channel/UC_r-M-0JQZUnOG2gJSL9pfg" target="_blank">Kanal</a>  abonnieren, um kein weiteres Video zu verpassen. Gerne kannst du auch in einem Kommentar schreiben, welche Themen dich besonders interessieren würden.</p><h2>Aber gibt es nicht schon genug AI Buzzwords?</h2><p>Bei codecentric arbeiten erfahrene Data Scientists und wir setzen Machine Learning und neuronale Netze bereits in diversen Projekten ein. Dennoch sind wir der Meinung, dass in Deutschland noch zu wenig Know-How in diesen Bereichen vorhanden ist.</p><p>Große Firmen wie Amazon, Google und Facebook investieren unvorstellbare Summen in AI/KI und haben bereits einen scheinbar uneinholbaren Vorsprung erarbeitet. Einige Forscher sind der Meinung, dass der Impact von künstlicher Intelligenz in naher Zukunft größer sein wird als der des Internets. Wir sind zwar (mindestens) noch Jahrzehnte von einer AI entfernt, die annähernd so viele Fähigkeiten wie ein Mensch kombinieren kann – dafür müsste allein schon die existierende Hardware noch um Größenordnungen schneller und besser werden. Aber die existierende KI-Technologie wird weitere Branchen auf den Kopf stellen, die bisher noch als „nicht automatisierbar“ gelten – da ist nicht mehr die Frage, ob es passieren wird sondern nur noch wann.</p><p>Es gibt viele Leute, die sich vor Jahren schon einmal mit neuronalen Netzen beschäftigt haben. „Damals“ schien es so, als sei die Technik noch nicht bereit, um damit sinnvolle Produkte bauen zu können. Viele sehen daher das Thema etwas voreingenommen und betrachten die aktuelle Entwicklung nur als Buzzword-Bingo. Auch mir ging es im Bereich NLP so. Ich habe lange gebraucht, um meine Vorurteile zu überwinden und zu bemerken, dass mein „Google-Navi“ inzwischen sehr gut versteht, wo ich hinfahren möchte und es absolut nicht mehr notwendig ist, die Zieladresse fummelig auf dem Handy einzutippen.</p><p>In den letzten Jahren ist sehr viel passiert. Gerade im Bereich Computer Vision wurden riesige Fortschritte gemacht. In der Forschung kommen so viele Papers heraus, die den State-of-the-Art immer weiter nach vorne treiben, dass man diese gar nicht mehr alle lesen kann. In der Computer Vision wurden Good Practices erarbeitet, die es ermöglichen mit weniger Daten viel bessere Ergebnisse zu erzielen (z.B. pretrained networks, transfer learning, fine tuning etc.). Diese Good Practices haben zu einer enormen Verbesserung geführt und auch dazu, dass „jedermann“ mit breit verfügbaren Daten in das Gebiet einsteigen kann. In anderen Disziplinen (z.B. NLP) werden viele Good Practices aber noch gar nicht oder kaum umgesetzt – das heisst, dass auch dort weiterhin mit grossen Fortschritten zu rechnen ist.</p><p>Ich bin der Meinung, dass es sich lohnt, das Thema noch einmal unvoreingenommen zu betrachten. Ausserdem denke ich, dass sich deutsche und europäische Konzerne viel mehr mit den Themen beschäftigen sollten und Experten-Teams und Know-How aufbauen müssen, um nicht den Anschluss zu verlieren.</p><p>Wenn ihr also auf dem Laufenden bleiben wollt, was in der Welt der Künstlichen Intelligenz so möglich ist und euch vielleicht auch selber mal an der ein oder anderen neuen Technik versuchen wollt, dann abonniert unseren <a href="https://www.youtube.com/channel/UC_r-M-0JQZUnOG2gJSL9pfg" target="_blank">codecentric.AI YouTube-Kanal</a> !</p>

Künstliche Intelligenz Initiative: „codecentric.AI“

<p><strong>Big Data – ein Schlagwort, das zur Zeit in aller Munde ist, egal ob in nerdigen Blogs, wissenschaftlichen Artikeln oder der Tageszeitung. Doch wie funktionieren Analysen von Big Data eigentlich? Um das heraus zu finden, habe ich an dem <a href="https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/">Workshop über „Deep Learning mit Keras und TensorFlow“</a>  teilgenommen.</strong></p><p>An einem stürmischen Donnerstagmittag erwarten uns in der modernen lichtdurchfluteten Eingangshalle der codecentric AG der Performance-Experte Dieter Dirkes und die Data Scientistin Dr. Shirin Glander. Shirin hat uns zwei Tage lang sehr anschaulich in die Geheimnisse von Deep Learning eingeführt und uns dabei geholfen, unser erstes eigenes Neuronales Netz zu programmieren. Nach einer kurzen Vorstellungsrunde der Teilnehmenden wurde deutlich, dass Deep Learning in sehr vielen verschiedenen Bereichen von Interesse ist: Die Geologen möchten (Luft-)Bilder klassifizieren, die Energiewirtschaft Zeitreihen analysieren, die Versicherungsbranche Zahlen vorhersagen und ich als Geisteswissenschaftlerin möchte Text klassifizieren. Auch für codecentric selbst bestand ein großes Interesse daran, mit den Möglichkeiten des Deep Learnings vertraut zu werden, sodass ein Drittel der Workshop-Teilnehmer eigene Mitarbeiter waren.</p><p>Der zweite Tag begann mit einem leckeren Latte Macchiato und einem netten „Guten Morgen“ in der großzügigen Kaffeeküche von codecentric. Der freundlich gestaltete Raum mit echtem Moos an der einzigen nicht verglasten Wand strahlt eine kreative Atmosphäre aus, die den Start in den Tag erleichterte. Shirin hatte für diesen Tag ein Neuronales Netz in R programmiert, an dem wir das Gelernte anwenden und ausprobieren konnten. Wir verbrachten viel Zeit damit, die verschiedenen Parameter zu verändern und die Auswirkungen auf die Performance des Neuronalen Netzes zu beobachten. Bei der praktischen Arbeit kamen immer wieder Fragen auf, die Shirin gerne beantwortete. Auch die eigenen Projekte der Teilnehmer wurden angesprochen und mit Shirins Hilfe weiter durchdacht.</p><h2>Deep Learning mit künstlichen Neuronalen Netzen</h2><p>Hochkomplexe Datenanalysen werden heute mit Hilfe von Deep Learning mit künstlichen Neuronalen Netzen durchgeführt. Deep Learning ist ein Teilbereich des Machine Learning, das wiederum zur Künstlichen Intelligenz gehört. Vorbild ist das menschliche Gehirn, das wunderbar dazu geeignet ist, Dinge zu lernen und das Gelernte auf Neues zu übertragen. Forscher versuchen dies mit künstlichen Neuronalen Netzen nachzuahmen, die anhand von Trainingsdaten etwas lernen, das sie dann auf neue Daten anwenden.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hTy5cLBBQtGIuQoG6SH6"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hTy5cLBBQtGIuQoG6SH6" alt="Gehirn vs Artificial Neural Network" width="700" height="202" /></a> </p><p>Bereits 1958 stellte Frank Rosenblatt [1] sein Konzept eines künstlichen Neuronalen Netzes vor, das sogenannte <em>Perzeptron</em>. Das Perzeptron verarbeitet numerischen Input anhand von gewichteten Verknüpfungen in einem künstlichen Neuron; zusammen mit einer Aktivierungsfunktion kommt es dann zu einem eindeutigen Ergebnis.</p><p>Mit steigender Rechenkraft von Computern und zunehmenden Datenmengen, wurden im Laufe der Jahre mehrschichtige Perzeptrone und tiefere Neuronale Netz-Strukturen entwickelt. Parallel dazu entstanden auch immer mehr Deep Learning Frameworks, Bibliotheken und Programmierschnittstellen in den verschiedenen Programmiersprachen, sodass es heute ein ein vielfältiges Angebot an benutzerfreundlichen und freiverfügbaren Materialien gibt. Die Hürde in dieses komplexe Thema einzusteigen ist also so niedrig wie nie zuvor, da kaum noch mathematisches Wissen vorausgesetzt wird, um Neuronale Netze bauen zu können.</p><h2>TensorFlow und Keras</h2><p>TensorFlow und Keras sind solche Deep Learning Programmierschnittstellen, kurz APIs. TensorFlow wurde von Google Brain in Python und C++ entwickelt und ist mittlerweile eine viel verwendete Open-Source Bibliothek für Machine Learning. Keras setzt darauf auf und ist auf Neuronale Netze spezialisiert. Es ist ebenfalls Open-Source und in Python programmiert. Neben TensorFlow gibt es noch einige weitere Bibliotheken, die als Backend für Keras genutzt werden können, so z. B. Theano und CNTK. TensorFlow basiert auf dem Konzept der <em>data flow graphs</em>, sodass jedes Neuronale Netz in Form von mathematischen Operationen als Knoten und multidimensionalen Datenspeichern, sogenannten <em>Tensors</em>, als Kanten visualisiert werden kann. In TensorFlow integriert findet sich das darauf spezialisierte Werkzeug: TensorBoard. TensorBoard ist eine Sammlung von Visualisierungswerkzeugen, die das Prozessverständnis, die Fehlersuche und die Optimierung in einem Neuronalen Netz durch die visuelle Aufbereitung vereinfachen.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ABkG5HwQFmFwnuUFOmiG"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ABkG5HwQFmFwnuUFOmiG" alt="TensorBoard Beispiel" width="700" height="359" /></a> </p><h2>Klassifizierung von Bildern mit Neuronalen Netzen</h2><p>Die bisherige Forschung im Bereich der Neuronalen Netze beschäftigte sich vor allem mit der Klassifikation von Bildern. Der wohl bekannteste Datensatz dafür ist MNIST [2], der handgeschriebene Ziffern in Bildern mit 28 x 28 Pixeln und ihre zugehörigen Label enthält. Er eignet sich ideal als Einstieg in die Bildklassifikation mit Neuronalen Netzen. Die Klassifikation mit Neuronalen Netzen gehört in die Kategorie des überwachten Lernens (engl.: <em>supervised learning</em>), da das Neuronale Netz anhand von Beispielen trainiert wird. Die handgeschriebenen Ziffern des MNIST-Datensatzes können dazu verwendet werden, eine Klassifikation zu lernen, das heißt, welche Anordnung von schwarzen Pixeln welcher Ziffer entspricht.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/TeBL5sN6TZCBCNbJnNML"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/TeBL5sN6TZCBCNbJnNML" alt="MNIST Dataset" width="530" height="297" /></a> </p><p>Zu Anfang bekommt das Netz viele verschiedene Inputdaten aus dem Trainingsdatensatz, die es mit zufällig gewählten Anfangsgewichten an eine nachfolgende Neuronenschicht übergibt. Für jedes Neuron einer Neuronenschicht wird anhand der eingehenden Daten und Gewichte ein Output berechnet, der wiederum an weitere Neuronenschichten gesendet wird. In der Ausgabeschicht wird durch eine Softmaxfunktion die Wahrscheinlichkeit angegeben, mit der ein Input in eine Klasse gehört. Die Vorhersage des Neuronalen Netzes ist die Klasse mit der höchsten Wahrscheinlichkeit. Da die korrekte Lösung für jeden Input in den Trainingsdaten bekannt ist, kann nun die Differenz zwischen der Vorhersage des Neuronalen Netzes und dem korrekten Label dieses Inputs berechnet werden. Diese Differenz ist die sogenannte Cross-Entropy. Wenn eine Cross-Entropy von 0 berechnet werden würde, hätte das Neuronale Netz mit 100%-iger Sicherheit die richtige Vorhersage getroffen. Am Ende eines Trainingszyklus wird eine Fehlerrate (engl.: <em>loss</em>) errechnet, die die gesamte Cross-Entropy eines Trainingssets ist.</p><p>Ziel des Trainings ist es, die Lossfunktion zu minimieren. Um dies zu erreichen, müssen die Gewichte zu den Neuronen angepasst (optimiert) werden, z. B. durch ein Backpropagation-Verfahren mit Stochastic Gradient Descent-Optimierung. Die Richtung der Anpassung wird über einen Gradienten gesucht, zu dessen Minimum „hinabgestiegen“ werden soll. Die Schritte des Abstiegs werden durch die sogenannte <em>Lernrate</em> beschrieben. Sie kann mit großen Schritten beginnen, um lokale Minima zu überschreiten, sollte jedoch im Laufe des Trainings verringert werden, damit das globale Minimum erreicht werden kann. Bei einer Lossfunktion von 0 wäre das globale Minimum erreicht und das Neuronale Netz hätte perfekt gelernt.</p><p>Wie gut das Neuronale Netz wirklich funktioniert, oder ob es nur den Trainingsdatensatz gelernt hat, wird deutlich, wenn es auf einen vorher unbekannten Testdatensatz angewendet wird. Wie bereits an dieser Stelle deutlich wird, gibt es viele verschiedene Parameter, an denen gedreht werden kann, um die optimale Einstellung für die Klassifikation mit einem Neuronalen Netz zu finden. Was die beste Einstellung ist, lässt sich über Ausprobieren verschiedenster Kombinationen herausfinden.</p><p>An dieser Stelle möchte ich mich bei Shirin bedanken, es war ein toller Workshop! Du hast uns das komplexe Thema Deep Learning und Neuronale Netze ein großes Stück näher gebracht.</p><p>Maria Hartmann</p><p>—</p><p>Workshop-Beschreibung: <a href="https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/">https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/</a> </p><p>[1] Rosenblatt, Frank (1985). The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain. Web: <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.335.-3398&rep=rep1&type=pdf">http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.335.-3398&rep=rep1&type=pdf</a> </p><p>[2] LeCun, Yann. The MNIST Database of Handwritten Digits. Web: http://yann.lecun.com/-exdb/mnist/</p><p>—</p><p><em>Gastautorin Maria Hartmann studiert Digital Humanities<span> an der Universität Trier. Über ihre </span><span>Liebe zur Sprachwissenschaft ist sie zur Klassifikation von semistrukturierten Texten mit Neuronalen Netzen gekommen, worüber sie jetzt ihre Masterarbeit schreibt. TensorFlow und Keras erleichtern ihr den Einstieg in das komplexe Thema. </span></em></p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/lZmqvzmQYu37S5rR88V8"><img loading="lazy" width="250" height="125" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/lZmqvzmQYu37S5rR88V8" alt="maria_hartmann" /></a> </p><p> </p>

Deep Learning Workshop bei der codecentric AG in Solingen

<div><p>In unserem neuesten <a href="https://www.youtube.com/codecentricAI" target="_blank">codecentric.AI-Video</a>  geben wir eine kurze <a href="https://youtu.be/Quhy_yAz5OM" target="_blank">Einführung in Amazon SageMaker</a>  und zeigen, wie man damit schnell und einfach ein Bildklassifikationsmodell trainieren kann, das Brillenträger von Nicht-Brillenträgern unterscheidet.</p><div><div><div> <img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/3vetaHzSeOHE1fJOevJw" alt="YouTube" /><div><p>Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.<br /><a href="https://policies.google.com/privacy" target="_blank">Mehr erfahren</a> <br /></p><p><a href="#">Video laden</a> </p><p> <small>YouTube immer entsperren</small></p></div></div></div><div></div></div><div><h2>Was ist Amazon SageMaker</h2><p><a href="https://aws.amazon.com/de/sagemaker/">Amazon SageMaker</a>  ist Teil der Amazon Web Services (<a href="https://www.codecentric.de/partner/aws">AWS</a> ) und</p><blockquote><p>“ist eine vollständig verwaltete Plattform, die es Entwicklern und Datenwissenschaftlern ermöglicht, schnell und einfach Machine-Learning-Modelle jeder Größenordnung zu erstellen, zu trainieren und zu implementieren.” <a href="https://aws.amazon.com/de/sagemaker/" target="_blank">https://aws.amazon.com/de/sagemaker/</a> </p></blockquote><p>SageMaker ist ein vollständig verwalteter Service, der den gesamten Machine-Learning-Prozess – vom Erstellen, über das Trainieren, bis hin zum Deployment von Machine-Learning-Modellen – so einfach wie möglich machen soll. Verfügbar ist SageMaker in Irland und in den USA.</p><p><img loading="lazy" width="720" height="405" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/OzpOKq3sQu4ibr2JLQwc" alt="SageMaker Machine Learning Prozess" /></p><p>Dabei werden viele der “alten Bekannten” aus der <a href="https://www.codecentric.de/partner/aws">AWS</a> -Umgebung in den Ablauf integriert verwendet: Trainingsdaten, Modellartefakte und Modellparameter werden in <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html" target="_blank">S3-Buckets</a>  gespeichert, wir können <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/gs-account.html#gs-account-user" target="_blank">IAM-User mit SageMaker-Berechtigung</a>  erstellen, und die <a href="https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-notebook-instance.html" target="_blank">Modelle laufen auf EC2-Instanzen</a> . Die Vorbereitung der Daten sowie das Trainieren selbst erfolgen in <a href="https://jupyter-notebook.readthedocs.io/en/stable/" target="_blank">Juypter Notebooks</a> , die in einer Notebook-Instanz laufen. Hierfür können grundsätzlich zwei Methoden verwendet werden: <em>boto3</em>, die <a href="https://aws.amazon.com/de/sdk-for-python/" target="_blank">AWS SDK für Python</a>  oder eine <a href="https://github.com/aws/sagemaker-python-sdk" target="_blank">high-level Pythonbibliothek</a> . Jupyter Notebooks hießen früher iPython Notebooks und wurden als Open-Source-Alternative zu Wolfram Notebooks entwickelt; die Notebooks laufen im Web Browser und kombinieren Code (in der Regel Python aber auch Kernel für R, Julia, oder andere Sprachen können eingerichtet werden) mit Markdown-Elementen und zeigen den Output direkt unterhalb der Code-Chunks an. Für die gestartete SageMaker-Instanz öffnet sich ein Dashboard, das alle Dateien in unserer Instanz anzeigt und von dem aus wir auch neue Notebooks erstellen können. Es gibt eine Reihe von “fertigen” Kernels, die viele der gängigen Datenverarbeitungs- und Analysepakete schon vorinstalliert haben (zum Beispiel conda für Python3 oder Python2, für TensorFlow oder MXNet). Deployen können wir ein fertiges Modell dann mit den <a href="https://docs.aws.amazon.com/de_de/sagemaker/latest/dg/how-it-works-hosting.html" target="_blank">Amazon SageMaker Hosting Services</a> .</p><p>Für das Trainieren von Modellen kann aus verschiedenen Algorithmen gewählt werden. Eine Übersicht gibt es <a href="https://docs.aws.amazon.com/de_de/sagemaker/latest/dg/algos.html" target="_blank">hier</a> . SageMaker hat gängige Machine-Learning-Algorithmen reimplementiert um Parallelisierung zu ermöglichen bzw. zu vereinfachen. So kann effektiv und schnell auch mit größeren Datenmengen gearbeitet werden. Wer speziellere Anwendungsfälle hat, kann auch eigene Algorithmen nutzen; die können dann als Docker Image zur Verfügung gestellt werden. Auch ermöglicht SageMaker sehr gute Skalierbarkeit, da die Trainings- und Hostinginstanzen jederzeit angepasst werden können, um mit größeren Datenmengen umgehen zu können. Auch können mehrere Modelle gleichzeitig deployed werden und somit produktiv laufen.</p></div><div><h2>Was brauche ich, um dem Video-Tutorial folgen zu können?</h2><p>Da SageMaker in die <a href="https://www.codecentric.de/partner/aws">AWS</a> -Welt eingebettet ist, benötigt man zunächst einen AWS Account. Das Registrieren bei <a href="https://www.codecentric.de/partner/aws">AWS</a>  ist an sich kostenlos, man braucht nur eine E-mail-Adresse, Passwort und Kreditkarteninformationen, um genutzte Services abrechnen zu können. Die ersten zwei Monate kann SageMaker kostenlos getestet werden. Aber Achtung: Das Aktivieren des Kontos kann bis zu 24 Stunden dauern!</p><p>Empfohlen wird, alle Analysen und Co. nicht mit dem Root User zu machen, sondern für jedes Projekt dedizierte IAM-User anzulegen und diesen die entsprechenden Rechte zu geben. Der Grund ist schlicht, dass dieses Vorgehen größere Sicherheit und Kontrolle gibt. Für SageMaker benötigt der IAM-User die sogenannten „AmazonSageMakerFullAcess“-Rechte. Der <a href="https://github.com/codecentric/codecentric.AI/blob/master/simple_deeplearning_aws_sagemaker/glasses-classifier.ipynb" target="_blank">komplette Code</a>  ist hier in Python geschrieben, Grundkenntnisse in Python sind also empfehlenswert. Außerdem ist es hilfreich, wenn man schon mal mit Jupyter gearbeitet hat (aber selbst wenn nicht, erschließt sich Jupyter sehr schnell).</p></div><div><h2>Kosten</h2><p>Die einzelnen Preise sind stark von der Menge der Daten, der genutzten Instanzen und der Trainingszeit abhängig. Auch für das Deployment und Abfragen der deployten Modelle fallen Kosten an. Eine Übersicht ist <a href="https://aws.amazon.com/de/sagemaker/pricing/" target="_blank">hier</a>  zu finden.</p></div><div><h2>Brillen-Klassifikation mit SageMaker</h2><p>In dem Video zeigen wir, wie wir einen Image-Classifier für einen Datensatz mit <a href="https://www.codecentric.de/ueber-uns/team/">codecentric-Mitarbeiterfotos</a>  entwickelt haben. Unser Datensatz enthält 460 Bilder. Wir verwenden ein tiefes neuronales Netz. Mit Transfer Learning wird es so traininert, dass es unsere Bilder in die Klassen „Brille“ und „keine-Brille“ einteilt. Transfer Learning macht es möglich, dass wir selbst mit diesem kleinen Datensatz gute Ergebnisse erzielen können. Für SageMaker gibt es eine Reihe von Beispiel-Notebooks, die zeigen, wie SageMaker verwendet werden kann. Diese Demo orientiert sich an diesen Beispiel-Notebooks (speziell an: <strong>Image-classification-lst-format.ipynb</strong>). Unser fertiges SageMaker Notebook ist <a href="https://github.com/codecentric/codecentric.AI/blob/master/simple_deeplearning_aws_sagemaker/glasses-classifier.ipynb" target="_blank">hier bei Github zu finden</a> .</p><p><img loading="lazy" width="1582" height="902" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/CUcLOqLrTxUKBMyoI4gg" alt="codecentric-Mitarbeiterfotos" /></p><p>In dem Video-Tutorial demonstrieren wir, wie wir zunächst die Bilder vorbereiten und für das Modell zugänglich machen. Dann teilen wir sie in Trainings-, Validierungs- und Testdaten auf. Im nächsten Schritt definieren und konfigurieren wir den TrainingsJob. Der Anfrage an die CreateTrainingJob API müssen wir dafür folgende Informationen mitgeben:</p><ul><li>den Algorithmus (als Pfad zum entsprechenden Container)</li><li>die Hyperparameter</li><li>Input- & Output-Konfiguration (als Pfad zu den entsprechenden S3-Buckets und Ressourcen)</li></ul><p>Die Ergebnisse des Trainings, also das Modell plus Konfiguration, sind in unserem S3-Bucket gespeichert.</p><p>Und schließlich konfigurieren wir den Endpunkt für das fertige Modell und deployen ihn. Denn um Vorhersagen mit einem Modell machen zu können, müssen wir es zuerst deployen; das passiert in drei Schritten:</p><ul><li>Modelle erstellen (Hier geben wir den Pfad zum S3-Bucket an, in dem die Trainingsergebnisse gespeichert wurden.)</li><li>Endpunkt konfigurieren</li><li>Endpunkt erstellen (Wenn der Endpunkt erstellt ist, werden die entsprechenden Machine-Learning-Instanzen hochgefahren, das Modell wird deployed und der Endpoint kann nun angesprochen werden.)</li></ul><p>So können wir per API auf unser Modell zugreifen und die Testbilder evaluieren.</p><p>Wenn wir unsere TrainingsJobs, Instanzen etc. überwachen wollen (was in der Praxis immer eine gute Idee ist), müssen die entsprechenden Logs in der Erstellung der Buckets und Instanzen aktiviert sein. Dann können wir die Ergebnisse der Log-Files im SageMaker Dashboard oder in Amazon CloudWatch anzeigen lassen.</p><p>Am Ende müssen wir noch “aufräumen”; das heißt, alle Ressourcen, die wir nicht mehr benötigen (wie S3-Buckets, Notebook-Instanzen, Modelle und Endpunkte), sollten wir stoppen oder löschen. Ansonsten fallen dafür weitere Kosten an.</p></div><div><h2>Weiterführende Informationen und Source Code:</h2><p>Amazon SageMaker Dokumentation: <a href="https://aws.amazon.com/de/documentation/sagemaker/" target="_blank">https://aws.amazon.com/de/documentation/sagemaker/</a> <br /> Link zum Source Code: <a href="https://github.com/codecentric/codecentric.AI/blob/master/simple_deeplearning_aws_sagemaker/glasses-classifier.ipynb" target="_blank">https://github.com/codecentric/codecentric.AI/blob/master/simple_deeplearning_aws_sagemaker/glasses-classifier.ipynb</a> </p></div></div>

Simple Deep Learning mit Amazon SageMaker

The Good, the Bad and the Ugly: Daten effektiv visualisieren und kommunizieren

<div><h2>Was ist Fraud und was macht es für Data Science interessant?</h2><p>Im Zusammenhang mit Data Science beschreibt das englische Wort „Fraud“ in der Regel Betrug im Online-, Kreditkarten- oder Versicherungsgeschäft. Betrugsversuche bei Geschäftsabschlüssen gibt es seitdem Menschen miteinander Handel treiben. Aber gerade durch die starke Zunahme von Online-Transaktionen hat sich für Betrüger ein neues breites Feld aufgetan. Fraud ist inzwischen zu einem weit verbreiteten Problem im E-Commerce geworden, und Firmen investieren viele Ressourcen, um ihn zu erkennen und zu verhindern.</p><p>Traditionelle Herangehensweisen zur Fraud-Prävention basieren auf durch Experten festgelegten Regeln; erfüllt eine Transaktion eine oder mehrere dieser Regeln, wird sie geflaggt. Ein Nachteil dieses Systems ist, dass es unflexibel ist und nur langsam auf neue Betrugsmaschen reagiert.<br /> Die moderne Alternative ist, die großen Datenmengen, die bei Online-Transaktionen anfallen, zu sammeln und für die Fraud-Erkennung zu nutzen. In solchen Anwendungsfällen sind Data-Science- und Machine-Learning-Techniken, wie Deep Neural Networks, die offensichtliche Lösung!</p><p>Hier zeige ich ein Beispiel dafür, wie Data-Science-Techniken genutzt werden können, um Fraud in Finanztransaktionen zu erkennen. Ich werde dabei einen Einblick in Fraud-Analyse-Methoden geben, der für Laien verständlich sein soll.</p></div><div><h2>Synthetisierte Finanz-Datensätze für Fraud-Erkennung</h2><p>Ein synthetisierter Finanz-Datensatz für Fraud-Erkennung ist bei Kaggle frei verfügbar. Er wurde anhand mehrerer echter Datensätze synthetisiert, um Standarddaten aus finanziellen Transaktionen möglichst realistisch darzustellen; wir bekommen dabei Informationen über 6.362.620 Transaktion in einem 30-tägigen Zeitraum (siehe Kaggle für Details und weitere Informationen).</p><p>Indem wir uns ein paar der wichtigsten Variablen (auch Feature genannt) ansehen, bekommen wir bereits ein Gefühl für die Daten. Die beiden nachstehenden Abbildungen zeigen zum Beispiel, dass es bei betrügerischen Transaktionen tendenziell um größere Summen Geld geht. Wenn wir uns zusätzlich die Art der Transaktion angucken, stellen wir außerdem fest, dass Fraud nur in Transfers und Cash-Out-Transaktionen vorkommt. Diese Information können wir nutzen, wenn wir die Daten für Machine-Learning-Modelle vorbereiten.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vtNKg4nZTvveqqZuZyq6"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vtNKg4nZTvveqqZuZyq6" alt="Betrügerische Transaktionen involvieren tendenziell größere Summen Geld." width="250" height="188" /></a> <p>Betrügerische Transaktionen involvieren tendenziell größere Summen Geld. Diese Abbildung zeigt die Verteilung der transferierten Geld-Summen (log + 1) in Fraud (Class = 1) und regulären (Class = 0) Transaktionen.</p></div><p></p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/x3AaZj7TN2GF7mHmWTN4"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/x3AaZj7TN2GF7mHmWTN4" alt="Fraud kommt nur in Transfers und Cash-Out-Transaktionen vor." width="250" height="208" /></a> <p>Fraud kommt nur in Transfers und Cash-Out-Transaktionen vor. Diese Abbildung zeigt die Verteilung der transferierten Geld-Summen (log + 1) in verschiedenen Transaktionsarten bei Fraud (Class = 1) und regulären (Class = 0) Transaktionen.</p></div><p></p></div></div><div><h2>Dimensionalitätsreduktion</h2><p>Für die Vorbereitung von Machine-Learning-Analysen sind Dimensionalitätsreduktion-Techniken hilfreiche Werkzeuge, um verborgene Muster in hoch-dimensionalen Datensätzen sichtbar zu machen. Darüber hinaus können wir sie nutzen, um die Anzahl an Features für das Machine Learning zu reduzieren ohne dabei essentielle Strukturen in den Daten zu verlieren. Ähnliche Herangehensweisen nutzen Clustering-Algorithmen, wie zum Beispiel k-Means Clustering.</p><p>Die am häufigsten verwendete Technik zur Dimensionalitätsreduktion ist die sogenannte „Principal Component Analyse“ (PCA). PCA erlaubt es uns, lineare Beziehungen zwischen Features in unseren Daten zu erkennen. Die erste Dimension, auch erste Principal Component (PC) genannt, spiegelt die größte Variation in unseren Daten wider, gefolgt von der zweiten PC mit der zweitgrößten Variation und so weiter. Wenn wir die ersten beiden Dimensionen in einem Streudiagramm gegeneinander auftragen, sehen wir Muster in unseren Daten: je unterschiedlicher zwei Proben in unserem Datensatz, desto größer ihr Abstand in der Abbildung. Allerdings ist PCA nicht in der Lage, komplexere Mustere in Daten zu finden. Für nicht-lineare Beziehungen zwischen Features können wir t-Distributed Stochastic Neighbor Embedding (t-SNE) verwenden. Im Gegensatz zu PCA zeigt t-SNE nicht nur die Unterschiedlichkeit von Proben, sondern zieht auch ihre Ähnlichkeit in Betracht, indem ähnliche Proben im Streudiagramm näher beieinander liegen. Dieser Unterschied mag nicht besonders gravierend klingen, aber wenn wir die beiden nachstehenden Abbildungen vergleichen, sehen wir, dass es deutlich einfacher ist, Cluster von Fraud-Fällen mit t-SNE zu finden als mit PCA. Beide Techniken können im Zusammenhang mit Machine Learning verwendet werden.</p><p>In dieser Beispielanalyse nutze ich Dimensionalitätsreduktion und Visualisierung zur Überprüfung der gelabelten Trainingsdaten. Da wir davon ausgehen können, dass nicht alle Fraud-Fälle auch als solche identifiziert wurden (und daher falsche Label zugewiesen bekommen haben), kann es sinnvoll sein, sich Proben, die nicht als Fraud gekennzeichnet wurden, aber in Clustern mit Fraud-Proben liegen, noch einmal genauer anzuschauen.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UgaWw3xPTMmvas8na1aM"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UgaWw3xPTMmvas8na1aM" alt="Techniken zur Dimensionalitätsreduktion in Fraud-Analyse." width="250" height="125" /></a> <p>Techniken zur Dimensionalitätsreduktion in Fraud-Analyse. Die Abbildungen zeigen die ersten beiden Dimensionen aus PCA (links) und t-SNE (rechts) für Fraud (Class = 1) und reguläre (Class = 0).</p></div></div></div><div><h2>Welche Machine-Learning-Algorithmen sind für Fraud-Analysen sinnvoll?</h2><p>Machine Learning ist ein weites Feld. Es umfasst eine Vielzahl von Algorithmen und Techniken, die für Klassifikation, Regression, Clustering oder Anomalie-Erkennung eingesetzt werden. Es werden zwei Hauptgruppen von Algorithmen, für „überwachtes“ (supervised) und „unüberwachtes“ Lernen (unsupervised learning), unterschieden.<br />  </p><ul><li><strong>Supervised Learning</strong> wird benutzt, um entweder die Werte einer gesuchten Antwortvariablen vorherzusagen (Regression), oder um Proben einer von mehreren vorgegebenen Klassen zuzuordnen (Klassifikation). Überwachte Algorithmen lernen unbekannte Proben anhand der Daten von Proben mit bekannten Antwortvariablen/Klassen vorherzusagen.</li></ul><p>Bei unserem Fraud-Beispiel handelt es sich streng genommen um ein Klassifikationsproblem: Jede Probe (entspricht jeweils einer Transaktion) hat ein entsprechendes Label, dass sie als Fraud (Class = 1) or regulär (Class = 0) klassifiziert. Es gibt allerdings zwei Hauptprobleme mit Supervised Learning und Fraud-Analyse:</p><ol><li><strong>Daten Labelling</strong>: Fraud ist in vielen Fällen schwer zu erkennen. Manche Betrugsversuche werden offensichtlich sein – diese sind mit Regel-basierten Systemen leicht zu erkennen und müssten nicht mit einem komplexen Modell analysiert werden. Interessant sind die Fälle, in denen subtiler Fraud begangen wird: Da wir nicht wissen, nach welchen Kriterien wir hier schauen müssen, werden diese Fälle mit traditionellen Methoden kaum erkannt. Hier kommt die Stärke von Machine Learning zum Tragen! Da wir Modelle beim Supervised Learning aber auf Grundlage von manuell vergebenen Labeln trainieren, ist es problematisch, wenn diese Label nicht oder nur teilweise stimmen. Wenn ein bestimmter Betrugsmechanismus bisher nicht aufgefallen und in unseren Daten als regulär gelabelt ist, werden überwachte Algorithmen diesen nicht erlernen können.</li><li><strong>Unsymmetrische Daten</strong>: Eine wichtige Eigenschaft von Fraud-Daten ist, dass sie extrem unsymmetrisch sind. Das bedeutet, dass eine Klasse extrem viel häufiger vorkommt als die andere; in unserem Beispiel sind nur weniger als 1% aller Transaktionen Fraud (siehe Abbildung „Synthetisierter Finanz-Datensatz für Fraud-Erkennung“). Die meisten Supervised-Learning-Algorithmen sind empfindlich gegenüber unsymmetrischen Klassen, und <a href="https://shiring.github.io/machine_learning/2017/04/02/unbalanced" target="_blank">spezielle Techniken</a>  müssen angewendet werden, um dies auszugleichen.</li></ol><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Gj9ndSsSiukTfFf2rRuO"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Gj9ndSsSiukTfFf2rRuO" alt="Synthetisierter Finanz-Datensatz für Fraud-Erkennung. " width="250" height="188" /></a> <p>Synthetisierter Finanz-Datensatz für Fraud-Erkennung. Fraud-Fälle sind selten im Vergleich zu regulären Transaktionen; im simulierten Beispieldatensatz sind weniger als 1% aller Transaktionen Fraud.</p></div></div><ul><li><strong>Unsupervised Learning</strong> benötigt keine vorgegebenen Antwortvariablen. Es wird genutzt, um Cluster oder Ausreißer/Anomalien in Datensätzen zu finden.</li></ul><p>In unserem Beispieldatensatz gehen wir davon aus, dass die Klassen-Label nicht zu 100% vertrauenswürdig sind. Aber wir können annehmen, dass Fraud-Fälle ausreichende Unterschiede zu regulären Transaktionen aufweisen, so dass Unsupervised-Learning-Algorithmen diese als Ausreißer oder Anomalien kennzeichnen.</p></div><div><h2>Anomalie-Erkennung mit Deep Learning Autoencodern</h2><p>Neuronale Netzwerke finden im Supervised- und Unsupervised-Learning-Anwendung. Autoencoder-Netzwerke werden für Anomalie-Erkennung im Unsupervised Learning genutzt; sie wenden sogenannte „Fehlerrückführung“ (backpropagation) an, um eine Annäherung an die Identitätsfunktion zu lernen, wobei die Output-Werte durch Minimierung des Rekonstruktionsfehlers den Input-Werten angeglichen werden sollen. Dadurch, dass der Rekonstruktionsfehler für die regulären Proben minimiert wurde, haben anormale Proben einen höheren Rekonstruktionsfehler.</p><p>Für die Modellbildungen nutze ich die Open-Source Software H2O über das R-Paket „h2o“. Auf dem oben beschriebenen Fraud-Beispieldatensatz wurde ein Unsupervised Neuronal Autoencoder Network trainiert (Gaußsche Verteilung, Quadratischer Loss, 209 Gewichte/Biases, 42.091.943 Trainingsproben, Mini-Batch Größe 1, 3 Hidden Layer mit [10, 2, 10] Knoten). Die Trainingsdaten enthalten nur reguläre Proben, so dass das Autoencoder-Modell die Struktur der „normalen“ Daten lernt. Testdaten sind eine Mischung aus regulären und Fraud-Proben. Im Hinterkopf zu behalten ist, dass Autoencoder-Modelle sensitiv auf Ausreißer reagieren; diese können typische Muster verschleiern. Mit diesem so trainierten Autoencoder-Modell können nun Ausreißer oder anormale Proben anhand des mittleren quadratischen Fehlers der Rekonstruktion (MSE) identifiziert werden: Transaktionen mit hohem MSE sind Anomalien im Vergleich zum globalen Muster in unseren Daten. Die unten stehende Abbildung zeigt, dass die Mehrheit der als Fraud gelabelten Testproben tatsächlich einen höheren MSE haben. Wir sehen außerdem einige als regulär gelabelte Transaktionen mit leicht erhöhtem MSE; diese könnten Fälle neuartiger Betrugsmaschen darstellen, die mit bisherigen Analysen unentdeckt geblieben sind.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/k2wPeX3vTw2LAmyngncM"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/k2wPeX3vTw2LAmyngncM" alt="Anomalien anhand des mittleren quadratischen Fehlers der Rekonstruktion (MSE)." width="250" height="125" /></a> <p>Diese Abbildung zeigt den mittleren quadratischen Fehlers der Rekonstruktion (MSE, y-Achse) für jede Transaktion (instance) im Testdatensatz (x-Achse); Punktefarben entsprechen dem manuell vergebenen Label (Fraud = 1, regulär = 0).</p></div></div></div><div><h2>Vortrainieren von Supervised-Learning-Modellen mit Autoencodern</h2><p>Autoencoder-Modelle können auch genutzt werden, um Supervised Learning Modelle vorzutrainieren. Auf einem unabhängigen Trainingsdatensatz wurde ein weiteres Deep Neural Network trainiert – dieses Mal als Klassifikationsmodell für die Antwortvariable „Class“ (Fraud = 1, regulär = 0) mit den initialen Gewichten aus dem Autoencoder-Modell (2-Klassen Klassifikation, Bernoulli Verteilung, CrossEntropy loss, 154 Gewichte/Biases, 111.836.076 Trainingsproben, Mini-Batch Größe 1, balance_classes = TRUE).</p><p>Modell-Performance wird anhand des selben Testsets gemessen, das in der Abbildung oben den MSE des Autoencoder-Modells zeigt. Die Abbildung unten zeigt den Vergleich von vorhergesagten mit tatsächlichen Klassifikations-Labeln. Da es sich bei unserem Beispiel um stark asymmetrische Daten handelt, muss die Performance des Modells anhand der selteneren Klasse, die für uns von Interesse ist (hier: Fraud = Klasse 1), gemessen werden. Würden wir uns die Genauigkeit (Accuracy) angucken, würde ein Modell, das nie die Klasse 1 vorhersagt, trotzdem eine Genauigkeit von > 99% erreichen. So ein Modell ist für unseren Anwendungsfall sinnlos. Deshalb schauen wir auf die Parameter „Sensitivität“ und „Präzision“: Wir wollen ein Modell, das so optimiert wurde, dass es möglichst viele Fraud-Proben im Testset als solche klassifiziert (Sensitivität), während gleichzeitig möglichst viele der Fraud-Klassifizierungen korrekt sind (Präzision).<br /> Ein optimales Ergebnis eines Supervised Neuronal Network für binäre Klassifikation ist in der nachstehenden Abbildung gezeigt.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LNMsQ9KQciCbWXuZCduT"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LNMsQ9KQciCbWXuZCduT" alt="Ergebnis eines Supervised Neuronal Network für binäre Klassifikation." width="250" height="125" /></a> <p>Ergebnis eines Supervised Neuronal Network für binäre Klassifikation. Die Abbildung zeigt die Prozentzahl der korrekt klassifizierten Transaktionen, indem tatsächliche (x-Achse) mit vorhergesagten Labeln verglichen werden (Farbe; Fraud = 1, regulär = 0).</p></div></div></div><div><h2>Können wir Machine-Learning-Modelle verstehen und ihnen vertrauen?</h2><p>Entscheidungen, die von Machine-Learning-Modellen getroffen wurden, sind inhärent schwierig – wenn nicht gar unmöglich – nachzuvollziehen. Die Komplexität einiger der besten Modelle, wie Neuronale Netzwerke, ist genau das, was sie so erfolgreich macht. Aber es macht sie gleichzeitig zu einer Black Box. Das kann problematisch sein, denn Geschäftsführer oder Vorstände werden weniger geneigt sein einer Entscheidung zu vertrauen und nach ihr zu handeln, wenn sie sie nicht verstehen.</p><p>Local Interpretable Model-Agnostic Explanations (LIME) ist ein Versuch, diese komplexen Modelle zumindest teilweise nachvollziehbar zu machen. Mit LIME können wir konkreter erklären, warum zum Beispiel eine als regulär gelabelte Transaktion als Fraud klassifiziert wurde. Die Methode wurde in dem Papier “Why Should I Trust You? Explaining the Predictions of Any Classifier.” von Marco Tulio Ribeiro, Sameer Singh und Carlos Guestrin von der University of Washington in Seattle publiziert. Sie nutzt die Tatsache, dass lineare Modelle leicht zu erklären sind; LIME sucht eine Approximation an das komplexe Modell, indem lokale lineare Modelle in Permutationen der Trainingsdaten angepasst werden. In jeder Permutation wird ein lineares Model angepasst und eine Gewichtung vorgenommen, so dass positive Gewichte eine Entscheidung unterstützen und negative Gewichte ihr widersprechen. In Summe ergibt das eine annäherungsweise Erklärung, wie viel und in welcher Art ein Feature zu einer Entscheidung des Modells beigetragen hat.</p></div><div><h2>Code</h2><p>Ein vollständiges Beispiel mit Code für das Trainieren eines Autoencoders sowie für LIME kann auf meinem persönlichen Blog nachgelesen werde:</p><ul><li><a href="https://shiring.github.io/machine_learning/2017/05/01/fraud" target="_blank">Autoencoders and anomaly detection with machine learning Part 1</a>  & <a href="https://shiring.github.io/machine_learning/2017/05/02/fraud_2" target="_blank">Part 2</a> </li><li><a href="https://shiring.github.io/machine_learning/2017/04/23/lime" target="_blank">Explaining complex machine learning models with LIME</a> </li></ul></div>

Fraud-Analyse mit Data-Science-Techniken

<p>Vor kurzem hat Matthias Radtke einen spannenden Blog-Artikel über <a href="/wissens-hub/blog/topic-modeling-codecentric-blog-articles">Topic Modeling der codecentric Blog-Artikel</a>  geschrieben. Dort gibt er eine umfassende Einführung in Topic Modeling. In diesem Artikel hier zeige ich ein reales Beispiel dafür, wie wir Data Science nutzen können, um Erkenntnisse aus Textdaten und Sozialer Netzwerk-Analyse zu ziehen.</p><p>Mit öffentlich zugänglichen Twitter-Daten charakterisiere ich codecentric’s Twitter Freunde und Follower, um</p><ul><li>die “einflussreichsten” Follower zu finden und mit Textanalyse-Tools, wie Sentimentanalyse, ihre Interessen aus den Profilbeschreibungen abzuleiten.</li><li>mit Sozialer Netzwerk-Analyse im Netzwerk von Freunden und Followern Schlüsselfiguren zu identifizieren, die Informationen an viele andere Nutzer weitergeben.</li><li>durch die Kombination von Netzwerk-Analyse mit Topic Modeling Meta-Gruppen mit ähnlichen Interessen zu identifizieren.</li></ul><p>Wenn wir die Interessen und die Position im sozialen Netzerk unserer Follower kennen, können wir Schlüsselfiguren identifizieren, die unsere Posts mit großer Wahrscheinlichkeit retweeten und dabei viele Leute erreichen.</p><div><h2>Twitter Mining</h2><p>Die <a href="https://dev.twitter.com/rest/public">Twitter REST API</a>  erlaubt es jedem auf Tweets, Timelines, Freunde- und Follower-Informationen zuzugreifen. Der Nachteil der REST API ist ihre Beschränkung auf 15 Anfragen pro 15-Minuten Fenster. Eine Alternative ist die <a href="https://dev.twitter.com/streaming/overview">Twitters’s Streaming API</a> , die geeignet ist um kontinuierlich Daten von bestimmten Benutzern, Themen oder Hash-Tags zu speichern. Hier betrachte ich eine Momentaufnahme von codecentric’s Twitter Freunden und Followern, um ein paar der Möglichkeiten zu zeigen, wie wir aus Analysen dieser Daten Nutzen ziehen können.</p><p>Am 15. Juli hatte codecentric 449 Freunde (Nutzer, denen codecentric folgt) und 2732 Follower (Nutzer, die codecentric folgen). Von diesen waren 261 sowohl Freunde, als auch Follower.</p><p>Wir haben jetzt die folgenden Informationen über diese Freunde und Follower:</p><ul><li>Name</li><li>Benutzername</li><li>Profilbeschreibung</li><li>Anzahl Tweets</li><li>Anzahl Follower</li><li>Anzahl Freunde</li><li>Datum, an dem der Account erstellt wurde</li><li>Ortsangabe im Profil</li><li>Spracheinstellung des Profils</li><li>etc.</li></ul><p>Diese Daten können uns eine Menge darüber verraten, wer sich für codecentric und unsere Themen interessiert. Wir können, z.B. mit einer einfachen explorativen Datenanalyse starten und uns anschauen, welche Sprachen die Nutzer-Accounts haben – (noch) ganz ohne komplizierte Modelle!</p></div><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/qafFd6QrSGOX4rua7x1f"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/qafFd6QrSGOX4rua7x1f" alt="Grafik Top 10 languages" width="150" height="150" /></a> <p>Top 10 Sprachen von codecentric’s Twitter Freunden und Followern.</p></div><div><p>Wie wir sehen können, spricht die Mehrheit Englisch oder Deutsch. Daraus können wir lernen, dass sowohl Tweets in Deutsch, als auch in Englisch eine entsprechende Zielgruppe unter unseren Followern haben (wobei Englisch vermutlich mehr Nutzer einschließt, sofern wir davon ausgehen, dass die meisten deutschen Follower ebenfalls Englisch verstehen).</p></div><div><h2>Wer sind codecentric’s einflußreichste Follower und wofür interessieren sie sich?</h2></div><p>Wir können auch versuchen unsere einflußreichsten Follower zu identifizieren. Das bedeutet, Follower mit einem großen Netzwerk (die also widerrum viele Follower haben) und die gleichzeitig viel tweeten/retweeten. Wenn wir es schaffen, das Interesse dieser Follower mit einem unserer Tweets zu wecken, ist es a) sehr wahrscheinlich, dass sie ihn retweeten und b) dass sie dabei ein großes Publikum erreichen!</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l4v4UecPQSG21djbMRIe"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l4v4UecPQSG21djbMRIe" alt="Grafik Korrelation zwischen Anzahl an Followern und der durchschnittlichen Anzahl an Tweets pro Tag" width="250" height="125" /></a> <p>Korrelation zwischen Anzahl an Followern und der durchschnittlichen Anzahl an Tweets pro Tag von codecentric’s Twitter Followern.</p></div><p>Die Abbildung oben zeigt die Korrelation zwischen der Anzahl an Followern von codecentric’s Followern und die Häufigkeit, mit der sie tweeten.</p><p>Mit dieser Information wissen wir nun, welche Follower besonders einflußreich sind. Im nächsten Schritt wollen wir wissen, für welche Themen sie sich interessieren. Dafür analysieren wir ihr Profilbeschreibungen. Daraus können wir dann ableiten, welche Tweets mit großer Wahrscheinlich für die Follower interessant sind. Das soll natürlich nicht heißen, dass nur diese Follower für uns wichtig sind und dass wir den Inhalt unserer Tweets (nur) nach ihnen ausrichten sollten! Ein breites Spektrum an Themen sorgt für ein interessantes, authentisches Profil – aber da Wissen ja bekanntermaßen Macht ist, kann es sehr wertvoll sein zu wissen, womit wir unsere Sichtbarkeit erhöhen können!</p><p>Um aus den Profilbeschreibungen der 100 einflußreichsten Follower (definiert mit einem Score aus Anzahl an Followern * durschnittliche Anzahl an Tweets pro Tag) Informationen zu ziehen, nutze ich Text- und Sprachanalysemethoden (natural language processing).</p><p>Die Daten werden vorbereitet, indem die Profilbeschreibungen zunächst in einzelne Wörter zerlegt und diese auf ihren Wortstamm reduziert werden. Außerdem entfernen wir sogenannte Stop-Wörter.</p><p>Wir können jetzt die am häufigsten verwendeten Wörter visualisieren.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QK7SEYRkS0OTZZB0z4OC"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QK7SEYRkS0OTZZB0z4OC" alt="Wordcloud mit den am häufigsten verwendeten Wortstämmen" width="150" height="150" /></a> <p>Wordcloud mit den am häufigsten verwendeten Wortstämmen in den Profilbeschreibungen von codecentric’s Twitter Followern.</p></div><p>Nicht überraschend finden wir software, development, agil und business unter den häufigsten Wörtern. Aber auch IoT (Internet of Things), data und science werden häufig in den Profilbeschreibungen unserer einflußreichen Follower genannt!</p><p>Statt uns einzelne Wörter anzugucken, können wir auch die Häufigkeit von Wortpaaren analysieren.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hqTLNoVTq6uR7NGMszYD"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hqTLNoVTq6uR7NGMszYD" alt="Grafik häufigste Wortpaare" width="700" height="438" /></a> <p>Häufigste Wortpaare in den Profilbeschreibungen von codecentric’s Twitter Followern.</p></div><div><div><p>Diese Abbildung zeigt die am häufigsten vorkommenden Wortpaare in den Profilbeschreibungen unserer einflußreichsten Follower. Pfeilfarben entsprechen der Häufigkeit. Da wir nur eine relativ kleine Gruppe an Followern analysieren, kommt keines der Wortpaare extrem häufig vor. Nichtsdestrotz ist “data science” das am meisten vorkommende Wortpaar!</p></div><div><h2>Sentimentanalyse</h2><p>Sentimentanalyse beschreibt eine Reihe von Techniken aus dem Natural Language Processing. Mit ihnen können wir Empfindungen wie Freude, Abscheu, Angst oder Wut und positive oder negative Gefühlslagen in Texten identifizieren.</p><p>Hier kommt auch wieder die Wortpaaranalyse zum Tragen. Die können wir hier nutzen um Wörter zu filtern, die auf Negierungen (“nicht”, “kein(e)”, etc.) folgen. Für die Sentimentanalyse können die Bedeutungen dieser negierten Wörter dann umgedreht werden.</p></div></div><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l2ha5htMQUCZGz6GjC7o"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l2ha5htMQUCZGz6GjC7o" alt="Grafik Sentiment-Score-Verteilung" width="250" height="94" /></a> <p>Sentiment-Score-Verteilung der Profilbeschreibungen von codecentric’s Twitter Followern.</p></div><div><div><p>This plot shows the overall sentiment in the user descriptions of the most influential followers. Based on Bing Liu’s sentiment lexicon, we can score how many positive and negative words were used in each followers’ description. Because this lexicon is only available for the English language, we can only get realiable scores for followers with an English description (68 out of 100 followers have an English language setting). As we can see, the majority of followers have predominantly positive descriptions.</p></div></div><div><div><p>Diese Abbildung zeigt die Summe der Sentiment-Scores für die Profilbeschreibungen der einflußreichsten Follower. Der Score berechnet sich aus der Summe der positiv und negativ besetzen Wörter (nach Bing Liu’s Sentiment Lexikon). Da das verwendete Lexikon nur für die englische Sprache etabliert ist, erfassen wir hier nur englische Wörter. Allerdings haben von unseren einflußreichsten Followern 68 von 100 englische Spracheinstellungen, so dass wir annehmen können, dass wir einen Großteil der Texte analysieren.</p></div><div><h2>Soziale Netzwerk-Analyse</h2><p>Soziale Netzwerke beschreiben Interaktionen zwischen Menschen, z.B. Twitter Freunde und Follower. Die Analyse solcher Netzwerke nutzt Techniken aus der Graphentheorie.</p><p>So können wir das Netzwerk von codecentric’s Twitter Freunden und Followern beschreiben: jeder Knoten zeigt einen Benutzer und Pfeile zeigen, wer wem folgt oder von wem gefolgt wird.</p><p>Aufgrund der Beschränkungen der Twitter API sehen wir hier nur einen Ausschnitt von 106 codecentric Freunden. Aber schon mit so einem kleinen Teil des Netzwerken bekommen wir fast 40 Millionen interagierende Nutzer.</p><p>Mit Graphentheorie können wir eine Vielzahl an Metriken berechnen, die uns Schlüsselfiguren im Netzwerk zeigen:</p><ul><li>Zentralität und Knoten “degree” zeigen uns, wie viele angrenzende Kanten die Knoten haben. Benutzer mit vielen Verbinden sind im Netzwerk von zentraler Rolle.</li><li>“Closeness” zeigt uns Nutzer, die im Netzwerk zentral liegen und somit Informationen an viele andere Nutzer weitergeben können.</li><li>Transivitiät oder Clustering Koeffizienten messen die Wahrscheinlichkeit, dass nahe beieinander liegende Knoten verbunden sind.</li><li>PageRank oder Eigenvektor-Zentralität ordnen Knoten anhand ihrer Verbindungen mit anderen stark vernetzen Knoten.</li><li>“Betweenness” Zentralität und “diameter” zeigen den kürzesten und längsten Pfad zwischen allen Knoten.</li></ul><p>In der nachstehenden Abbildung sehen wir das Netzwerk von codecentric’s Twitter Freunden und Followern. Knoten mit hoher “betweenness” Zentralität sind auf einem Pfad mit vielen anderen Knoten; diese Nutzer sind also Schlüsselverbindungen oder Brücken zu vielen verschiedenen Gruppen von anderen Nutzern. Durch ihre Position im Netzwerk sind diese Nutzer von besonderer Bedeutung für uns, denn sie können Informationen mit großer Reichweite verteilen. Knotenpositionen im Netzwerk wurden mit dem Fruchterman-Reingold Layout Algorithmus berechnet.</p></div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/RZd8bFxT3GNvjIYWBmJA"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/RZd8bFxT3GNvjIYWBmJA" alt="Grafik Soziales Netzwerk von codecentric’s Twitter Freunden und Followern" width="700" height="685" /></a> <p>Soziales Netzwerk von codecentric’s Twitter Freunden und Followern. Knotengröße entspricht “betweenness” Zentralität.</p></div><h2>Topic Modeling</h2><p>Im nächsten Schritt können wir mit Topic Modeling auf Basis der Profilbeschreibungen unsere Follower Themengruppen mit ähnlichen Interessen zuordnen. Eine umfassende Einführung in Topic Modeling kann in <a href="/wissens-hub/blog/topic-modeling-codecentric-blog-articles">Matthias Radtke’s “Topic Modeling of the codecentric Blog Articles”</a> nachgelesen werden.</p><p>Hier benutze ich “Latent Dirichlet Allocation” mit VEM Algorithmus um alle Nutzer aus dem Netzwerk in fünf Interessens-Gruppen einzuteilen.</p><p>Die Wordcloud unten visualisiert die charakteristischsten Wörter in den jeweiligen Gruppen.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/sGYiXiThSY0Mir9zO0MQ"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/sGYiXiThSY0Mir9zO0MQ" alt="Wordcloud der repräsentativsten Wörter in den fünf durch Topic Modelling identifizierten Gruppen" width="700" height="700" /></a> <p>Wordcloud der repräsentativsten Wörter in den fünf durch Topic Modelling identifizierten Gruppen.</p></div><p>Jetzt wollen noch wir wissen, welchen Themen wir den Nutzern in unserem Netzwerk zuordnen können. Dafür nutzen wir den sogenannten Gamma-Score, der für jeden Nutzer und jeder Themengruppe einen Wert entsprechend der berechneten Zugehörigkeit zuweist. Hier wird jedem Nutzer die Themengruppe mit höchstem Gamma-Score zugeteilt.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FoH59HV6SVHK5yHUMvAp"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FoH59HV6SVHK5yHUMvAp" alt="Grafik 2 Soziales Netzwerk von codecentric’s Twitter Freunden und Followern" width="700" height="741" /></a> <p>Soziales Netzwerk von codecentric’s Twitter Freunden und Followern. Knotenfarbe zeigt Zugehörigkeit zu den fünf durch Topic Modeling identifizierten Themengruppen</p></div><p>Dieses Netzwerk zeigt die verschiedenen Interessensgruppen von codecentric’s Twitter Freunden, basierend auf der Zuordnung zu Themengruppen von den Nutzern, denen sie folgen. Ein Nutzer scheint z.B. vielen Nutzern zu folgen, die in ihren Profilbeschreibungen Software Development nennen.</p><p>Obwohl dieses Netzwerk nicht repräsentativ ist, da es nur einen Ausschnitt der Twitter Freunde ersten und zweiten Grades zeigt, können wir hier sehen, welchen Potenzial in dieser Art von Information steckt! Denn wir haben jetzt einen guten Eindruck über die Interessen unserer Freunde gewonnen, anhand von a) ihren Twitter Beschreibungen und b) den Beschreibungen von allen Nutzern, denen sie auf Twitter folgen. Außerdem haben wir jetzt Hinweise auf die Interessen von Kontakten zweiten Grades, die uns (noch) nicht folgen. Das könnten wir nutzen, um Gruppen gezielt anzusprechen, indem wir z.B. Artikel mit Fokus auf diesen Themen veröffentlichen.</p><p>Es wäre sogar vorstellbar, dass wir diesen Ansatz um Machine Learning Techniken erweitern, um Follower Interessen und ihr Potenzial als Verteiler von Informationen vorherzusagen.</p><hr /><p>Alle Analysen wurden mit R version 3.4.0 durchgeführt.</p><p>Code ist einzusehen bei <a href="https://github.com/ShirinG/blog_posts_prep/blob/master/twitter/twitter_codecentric.Rmd">Github</a> .</p></div></div></div></div>

Soziale-Netzwerk-Analyse und Topic Modeling mit codecentrics Twitter-Freunden und -Followers

<p><strong>Big Data – a buzz word you can find everywhere these days, from nerdy blogs to scientific research papers and even in the news. But how does Big Data Analysis work, exactly? In order to find that out, I attended the workshop on <a href="https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/">“Deep Learning with Keras and TensorFlow”.</a>  </strong></p><p>On a stormy Thursday afternoon, we arrived at the modern and light-flooded codecentric AG headquarters. There, we met performance expert Dieter Dirkes and Data Scientist Dr. Shirin Glander. In the following two days, Shirin gave us a hands-on introduction into the secrets of Deep Learning and helped us to program our first Neural Net. After a short round of introduction of the participants, it became clear that many different areas and domains are interested in Deep Learning: geologists want to classify (satellite) images, energy providers want to analyse time-series, insurers want to predict numbers and I – a humanities major – want to classify text. And codecentric employees were also interested in getting to know the possibilities of Deep Learning, so that a third of the participants were employees from the company itself.</p><p>The second day began with a tasty Latte Macchiato and a nice “Good Morning” in the big kitchen of codecentric headquarters. The friendly room, with real moss on the only wall that’s not glass, emanated a very creative air and made the start of the day much easier. For this day, Shirin had a Neuronal Net prepared, that we could use to apply and try out what we’ve learned. We spent a lot of time exploring the effects that changing different parameters had on the performance of the Neural Net. During the practical part, many questions came up, that Shirin answered and discussed with us. We also talked about our own projects and ways to advance them with what we learned in the workshop.</p><h2>Deep Learning with Artificial Neural Nets</h2><p>Artificial Neural Nets (ANN) can be used to analyse highly complex data. Deep Learning is a subdomain of machine learning, which is again a subdomain of Artificial Intelligence. ANNs are modelled after the human brain, which has been adapted to learn efficiently and transfer knowledge to new scenarios. Researchers tried to mimic the brains ability to learn by building ANN, which are able to learn from training data and transfer this knowledge to new data.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hTy5cLBBQtGIuQoG6SH6"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hTy5cLBBQtGIuQoG6SH6" alt="Gehirn vs Artificial Neural Network" width="700" height="202" /></a> </p><p>Already back in 1958, Frank Rosenblatt [1] presented his concept of ANNs, the so called perceptron. The perceptron works with a numeric input and uses weighted connections in a node or neuron; together with an activation function, it calculates the result.</p><p>With increasing computational power and increasing amounts of data, multi-layer perceptrons and deep neural nets became more and more prevalent. Alongside the boom in machine learning, more and more deep learning frameworks, libraries and programming interfaces were developed. Today, there is a plethora of easy-to-use and open-source materials for deep learning. The bar to get your feet wet with this complex topic is as low as never before; you need almost no deep mathematical knowledge any more in order to build neural nets.</p><h2>TensorFlow and Keras</h2><p>TensorFlow and Keras are such deep learning APIs. TensorFlow has been developed by Google Brain and has been written in Python and C++. Right now, it is one of the most often used open-source libraries for machine learning. Keras builds on top of it and works specifically with neural nets. Same as TensorFlow, it is open-source and has been written in Python. There are several other libraries that can be used as backend with Keras, e.g. Theano and CNTK. TensorFlow is based on the concept of <em>data flow graphs</em>, meaning that every neural net can be seen as a form of mathematical operation in nodes and multi-dimensional data objects, the so called tensors, as edges. With TensorFlow we can use the integrated TensorBoard. TensorBoard is a collection of visualisation tools, that makes it easy to analyse processes, potential errors and optimize neural nets.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ABkG5HwQFmFwnuUFOmiG"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ABkG5HwQFmFwnuUFOmiG" alt="TensorBoard Beispiel" width="700" height="359" /></a> </p><h2>Image classification with Neural Nets</h2><p>Most of the research into neural nets has so far involved image classification. The most famous data set for this task is MNIST [2], which contains 28 x 28 pixel images of hand-written images and their respective labels. The MNIST dataset is optimal for getting started with image classification and neural nets. Classification with neural nets falls into the category of supervised learning because it uses examples to train models. The hand-written digits of the MNIST dataset can be used to learn a classification task, namely which pixel arrangement corresponds to which digit.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/TeBL5sN6TZCBCNbJnNML"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/TeBL5sN6TZCBCNbJnNML" alt="MNIST Dataset" width="530" height="297" /></a> </p><p>The neural net will be fed input data from the training set, which it will pass on to the next layer of neurons. The initial weights were picked at random and every neuron in a layer will calculate an output based on the incoming data and the weights. The output will then be passed on again to following layers. In the final layer, a softmax function calculated the probabilities, with which it sorts the input image to the classes. The prediction of this input will be the class with the highest probability. Because we know the correct class for every image in our training set, we can calculate the difference between prediction and correct class. This is called cross-entropy. A cross-entropy of 0 would mean that the neural net predicted the correct class with 100% certainty. After every cycle of training, we calculate an error rate, the so called loss, which represents the cross-entropy of the entire training set.</p><p>During training, we aim to minimize the loss function. In order to achieve this, the weights of the neurons need to be optimized, e.g. by using backpropagation with stochastic gradient descent. The direction in which to change the weights is found with a gradient; we want to “descend” this gradient to find the smallest error rate. The step size with which we traverse the gradient landscape is defined by the learning rate. We can start with big steps to prevent getting stuck in local minima, but with advanced training we want to reduce the learning rate so that we can – ideally – reach the global minimum. With a loss function of 0, we would have achieved the perfect result.</p><p>The final evaluation of our neural net’s performance is measured on independent test data. We want to avoid that our net learned the training set too specifically and isn’t able to generalize any more. There are many different parameters that can be adjusted when training a neural net to find the optimal composition for our classification tasks. We try out different combinations and observe the effect they have on the result.</p><p>I want to thank Shirin for a great workshop! You made the complex topic of deep learning and neural nets much more accessible to us.</p><p>Maria Hartmann</p><p>—</p><p>Workshop description: <a href="https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/">https://www.codecentric.de/schulung/deep-learning-mit-keras-und-tensorflow/</a> </p><p>[1] Rosenblatt, Frank (1985). The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain. Web: <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.335.-3398&rep=rep1&type=pdf">http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.335.-3398&rep=rep1&type=pdf</a> </p><p>[2] LeCun, Yann. The MNIST Database of Handwritten Digits. Web: http://yann.lecun.com/-exdb/mnist/</p><p>—</p><p><em>Guest author Maria Hartmann studies Digital Humanities at the University of Trier. Through her love of linguistics she came to the classification of semi-structures texts with neural nets – which she now works on for her Master’s thesis. TensorFlow and Keras help her in her studies.</em></p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/lZmqvzmQYu37S5rR88V8"><img loading="lazy" width="250" height="125" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/lZmqvzmQYu37S5rR88V8" alt="maria_hartmann" /></a> </p>

Deep Learning Workshop at codecentric AG in Solingen

<div><h2>Predictive Maintenance</h2><p>Predictive Maintenance is an increasingly popular strategy associated with Industry 4.0; it uses advanced analytics and machine learning to optimize machine costs and output (see Google Trends plot below).</p><p>A common use case for Predictive Maintenance is to proactively monitor machines, so as to predict when a check-up is needed to reduce failure and maximize performance. In contrast to traditional maintenance, where each machine has to undergo regular routine check-ups, Predictive Maintenance can save costs and reduce downtime. A machine learning approach to such a problem would be to analyze machine failure over time to train a <a href="https://en.wikipedia.org/wiki/Supervised_learning" target="_blank">supervised classification model</a>  that predicts failure. Data from sensors and weather information is often used as features in modeling.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/C95AeUTySaSE23N1trkN"><img width="250" height="125" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/C95AeUTySaSE23N1trkN" alt="Google search requests for 'Predictive Maintenance' over the last 5 years" /></a> </p><p>With different analysis and modeling techniques, Predictive Maintenance can also optimize asset availability, productivity and output quality, extend machine life, lower safety risks and thus increase customer satisfaction. Predictive Maintenance is already being used with wind turbines, <a href="http://www.ecmweb.com/content/preventive-maintenance-motors-and-controls" target="_blank">motor engines</a> , cars and a multitude of other machines. It is often central to <a href="https://www.forbes.com/sites/bernardmarr/2017/05/05/internet-of-things-and-predictive-maintenance-transform-the-service-industry/#2b430267eaf4" target="_blank">IoT technologies</a> .</p></div><blockquote><p>You can interactively explore different analysis techniques for Predictive Maintenance with this flexdashboard (allow for a few seconds of loading time).</p></blockquote><div> Because Predictive Maintenance relies on large amounts of data collected over long periods of time, <a href="https://blog.codecentric.de/category/architektur/big-data/page/2/" target="_blank">Big Data techniques</a>  are needed.<ul><li><strong>Databases</strong>: The first step towards Predictive Maintenance is collecting and storing the data in an efficient and scalable way. There are <a href="http://www.computerweekly.com/feature/Big-data-storage-choices" target="_blank">many different ways to store Big Data</a> , either in the cloud or locally, like <a href="/wissens-hub/blog/einfuhrung-in-hadoop-was-ist-big-data-hadoop-teil-1-von-5" target="_blank">Hadoop</a> , <a href="https://www.codecentric.de/2017/04/06/digitalisierung-mit-codecentric-und-aws/" target="_blank">AWS</a>  and many more.</li><li><strong>Modeling</strong>: Once the data is collected, machine learning models can be trained. When working with Big Data, we need model scalability and distributed computing. Here, we can e.g. make use of <a href="https://www.codecentric.de/schulung/apache-spark-einfuehrungsworkshop-fuer-entwickler/" target="_blank">Apache Spark</a>  or similar cluster computing services.</li><li><strong>Prediction</strong>: When a suitable model has been trained, it can be used to predict future data points. With Predictive Maintenance, we generally talk about <a href="/wissens-hub/blog/distributed-stream-processing-frameworks-fast-big-data" target="_blank">(near) real-time analysis</a> .</li></ul></div><div><h2>flexdashboard</h2><p>With <a href="http://rmarkdown.rstudio.com/flexdashboard/" target="_blank">flexdashboard</a>  RStudio provides a great way to create interactive dashboards with R. It is an easy and very fast way to present analyses or create story maps. Here, I have used it to demonstrate different analysis techniques for Predictive Maintenance. It uses <a href="http://shiny.rstudio.com/" target="_blank">Shiny</a>  run-time to create interactive content.</p><p>Here, you can find the dashboard: https://shiring.shinyapps.io/demo_dashboard_pred_maint_fast/ (allow for a few seconds of loading time).</p><p>The dashboard contains an introduction to predictive maintenance (non-interactive), exploratory data analysis (here, you can select a feature for plotting), machine learning (here, you can choose a test case for which to show the prediction results), survival analysis (non-interactive) and time series forecasting (also non-interactive).</p><p>Each section contains text that explains the content, data, results and plots. The source code for the dashboard can be seen by clicking on the <strong></> Source Code</strong> field in the top right corner (code for preparing data and models is included as well but commented out).</p></div><div><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/EfeFHVA2S5JPHAjH5dX3" target="_blank"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/EfeFHVA2S5JPHAjH5dX3" alt="Dashboard screenshot showing the machine learning section of Predictive Maintenance" width="250" height="136" /></a> </p><p>—</p><p>With my other Shiny apps and flexdashboards you can explore:</p><ul><li>a supervised machine learning example for fraud detection (with H2O, OneR and LIME)(also takes a few seconds to load as data and model are quite big)</li><li>World Gender Statistics</li><li>disease-associated mutations in the human genome</li></ul></div>

Explore Predictive Maintenance with flexdashboard

<div><h2>What is fraud and why is it interesting for Data Science?</h2><p>Fraud can be defined as “the crime of getting money by deceiving people” (Cambridge Dictionary); it is as old as humanity: whenever two parties exchange goods or conduct business, there is the potential for one party scamming the other.<br /> With an ever-increasing use of the internet for shopping, banking, filing insurance claims etc., these businesses have become targets of fraud in a whole new dimension. Fraud has become a major problem in e-commerce and a lot of resources are being invested to recognize and prevent it.</p><p>Traditional approaches to identifying fraud have been rule-based. This means that hard and fast rules for flagging a transaction as fraudulent have to be established manually and in advance. But this system isn’t flexible and inevitably results in an arms race between the seller’s fraud detection system and criminals finding ways to circumnavigate these rules.<br /> The modern alternative is to leverage the vast amounts of Big Data that can be collected from online transactions and model it in a way that allows us to flag or predict fraud in future transactions. For this, Data Science and Machine Learning techniques such as Deep Neural Networks (DNNs) are the obvious solution!</p><p>Here, I am going to show an example of how Data Science techniques can be used to identify fraud in financial transactions. I will offer some insights into the inner workings of fraud analysis, aimed at non-experts to understand.</p></div><div><h2>Synthetic financial datasets for fraud detection</h2><p>A synthetic financial dataset for fraud detection is openly accessible via Kaggle. It has been generated from a number of real datasets to resemble standard data from financial operations and contains 6,362,620 transactions over 30 days (see Kaggle for details and more information).</p><p>By plotting a few major features, we can already get a sense of the data. The two plots below, for example, show us that fraudulent transactions tend to involve larger sums of money. When we also include the transaction type in the visualization, we find that fraud only occurs with tranfers and cash-out transactions and we can adapt our input features for machine learning accordingly.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vtNKg4nZTvveqqZuZyq6"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vtNKg4nZTvveqqZuZyq6" alt="Fraudulent transactions tend to involve larger sums of money. " width="250" height="188" /></a> <p>Fraudulent transactions tend to involve larger sums of money. This plot shows the distribution of transferred amounts of money (log + 1) in fraudulent (Class = 1) and regular (Class = 0) transactions.</p></div><p></p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/x3AaZj7TN2GF7mHmWTN4"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/x3AaZj7TN2GF7mHmWTN4" alt="Fraud only occurs with tranfers and cash-out transactions." width="250" height="208" /></a> <p>Fraud only occurs with tranfers and cash-out transactions. This plot shows the distribution of transferred amounts of money (log + 1) in different transaction types for fraudulent (Class = 1) and regular (Class = 0) transactions.</p></div><p></p></div></div><div><h2>Dimensionality reduction</h2><p>In preparation for machine learning analysis, dimensionality reduction techniques are powerful tools for identifying hidden patterns in high-dimensional datasets. In addition, we can use them to reduce the number of features for machine learning while preserving the most important patterns of the data. Similar approaches use clustering algorithms, like k-means clustering.</p><p>The most common dimensionality reduction technique is Principal Component Analysis (PCA). PCA is good at picking up linear relationships between features in the data. The first dimension, also called the first principal component (PC), reflects the majority of variation in our data, the second PC reflects the second-biggest variation and so on. When we plot the first two dimensions against each other in a scatterplot, we see patterns in our data: The more dissimilar two samples in our dataset, the farther apart they will be in a PCA plot. PCA will not be able to deal with more complex patterns, though. For non-linear patterns, we can use t-Distributed Stochastic Neighbor Embedding (t-SNE). In contrast to PCA, t-SNE will not only show sample dissimilarity, it will also account for similarity by clustering similar samples close together in a plot. This might not sound like a major difference, but when we look at the plots below, we can see that it is much easier to identify clusters of fraudulent transactions with t-SNE than with PCA. PCA and t-SNE can both be used with machine learning.</p><p>Here, I want to use dimensionality reduction and visualization to perform a sanity check on the labelled training data. Because we can assume that some fraud cases might not have been identified as such (and are therefore mis-labelled), we could now advise to take a closer look at non-fraud samples that cluster with fraud cases.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UgaWw3xPTMmvas8na1aM"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UgaWw3xPTMmvas8na1aM" alt="Dimensionality reduction techniques in fraud analytics." width="250" height="125" /></a> <p>Dimensionality reduction techniques in fraud analytics. The plots show the first two dimensions of PCA (left) and t-SNE (right) for fraudulent (Class = 1) and regular (Class = 0) transactions.</p></div></div></div><div><h2>Which Machine Learning algorithms are suitable for fraud analysis?</h2><p>Machine learning is a broad field. It encompasses a large collection of algorithms and techniques that are used in classification, regression, clustering or anomaly detection. Two main classes of algorithms, for supervised and unsupervised learning, can be distinguished.<br />  </p><ul><li><strong>Supervised learning</strong> is used to predict either the values of a response variable (regression tasks) or the labels of a set of pre-defined categories (classification tasks). Supervised learning algorithms learn how to predict unknown samples based on the data of samples with known response variables/labels.</li></ul><p>In our fraud detection example, we are technically dealing with a classification task: For each sample (i.e. transaction), the pre-defined label tells us whether it is fraudulent (1) or not (0). However, there are two main problems when using supervised learning algorithms for fraud detection:</p><ol><li><strong>Data labelling</strong>: In many cases, fraud is difficult to identify. Some cases will be glaringly obvious – these are easy to recognize with rule-based techniques and usually won’t require complex models. Where it becomes interesting are the subtle cases; they are hard to recognize as we don’t usually know what to look for. Here, the power of machine learning comes into play! But because fraud is hard to detect, training data sets from past transactions are probably not classified correctly in many of these subtle cases. This means that the pre-defined labels will be wrong for some of the transactions. If this is the case, supervised machine learning algorithms won’t be able to learn to find these types of fraud in future transactions.</li><li><strong>Unbalanced data</strong>: An important characteristic of fraud data is that it is highly unbalanced. This means that one class is much more frequent than the other; in our example, less than 1% of all transactions are fraudulent (see figure “Synthetic financial dataset for fraud detection”). Most supervised machine learning classification algorithms are sensitive to unbalance in the predictor classes, and <a href="https://shiring.github.io/machine_learning/2017/04/02/unbalanced" target="_blank">special techniques</a>  would have to be used to account for this unbalance.</li></ol><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Gj9ndSsSiukTfFf2rRuO"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Gj9ndSsSiukTfFf2rRuO" alt="Synthetic financial dataset for fraud detection. " width="250" height="188" /></a> <p>Synthetic financial dataset for fraud detection. Fraud cases are rare compared to regular transactions; in the simulated example dataset less than 1% of all transactions are fraudulent.</p></div></div><p> </p><ul><li><strong>Unsupervised learning</strong> doesn’t require pre-defined labels or response variables; it is used to identify clusters or outliers/anomalies in data sets.</li></ul><p>In our fraud example data set we don’t trust the predictor labels to be 100% correct. But we can assume that fraudulent transactions will be sufficiently different from the vast majority of regular transactions, so that unsupervised learning algorithms will flag them as anomalies or outliers.</p></div><div><h2>Anomaly detection with deep learning autoencoders</h2><p>Neural networks are applied to supervised and unsupervised learning tasks. Autoencoder neural networks are used for anomaly detection in unsupervised learning; they apply backpropagation to learn an approximation to the identity function, where the output values are equal to the input. They do so by minimizing the reconstruction error or loss. Because the reconstruction error is minimized according to the background signal of regular samples, anomalous samples will have a larger reconstruction error.</p><p>For modeling, I am using the open-source machine learning software H2O via the “h2o” R package. On the fraud example data set described above, an unsupervised neural network was trained using deep learning autoencoders (Gaussian distribution, quadratic loss, 209 weights/biases, 42,091,943 training samples, mini-batch size 1, 3 hidden layers with [10, 2, 10] nodes). The training set contains only non-fraud samples, so that the autoencoder model will learn the “normal” pattern in the data; test data contains a mix of non-fraud and fraud samples. We need to keep in mind, though, that autoencoder models will be sensitive to outliers in our data in that they might throw off otherwise typical patterns. This trained autoencoder model can now identify anomalies or outlier instances based on the reconstruction mean squared error (MSE): transactions with a high MSE are outliers compared to the global pattern of our data. The figure below shows that the majority of test cases that had been labelled as fraudulent indeed have a higher MSE. We can also see that a few regular cases have a slightly higher MSE; these might contain cases of novel fraud mechanisms that have been missed in previous analyses.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/k2wPeX3vTw2LAmyngncM"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/k2wPeX3vTw2LAmyngncM" alt="Anomalies based on reconstruction mean squared errors (MSE). " width="250" height="125" /></a> <p>This plot shows reconstruction MSE (y-axis) for every transaction (instance) in the test data set (x-axis); points are colored according to their pre-defined label (fraud = 1, regular = 0).</p></div></div></div><div><h2>Pre-training supervised models with autoencoders</h2><p>Autoencoder models can also be used for pre-training supervised learning models. On an independent training sample, another deep neural network was trained – this time for classification of the response variable “Class” (fraud = 1, regular = 0) using the weights from the autoencoder model for model fitting (2-class classification, Bernoulli distribution, CrossEntropy loss, 154 weights/biases, 111,836,076 training samples, mini-batch size 1, balance_classes = TRUE).</p><p>Model performance is evaluated on the same test set that was used for showing the MSE of the autoencoder model above. The plot below shows the predicted versus actual class labels. Because we are dealing with severely unbalanced data, we need to evaluate our model based on the rare class of interest, here fraud (class 1). If we looked at overall model accuracy, a model that never identifies instances as fraud would still achieve a > 99% accuracy. Such a model would not serve our purpose. We are therefore interested in the evaluation parameters “sensitivity” and “precision”: We want to optimize our model so that a high percentage of all fraud cases in the test set is predicted as fraud (sensitivity), and simultaneously a high percentage of all fraud predictions is correct (precision).<br /> An optimal outcome from training a supervised neural network for binary classification is shown in the plot below.</p><div><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LNMsQ9KQciCbWXuZCduT"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LNMsQ9KQciCbWXuZCduT" alt="Results from training a supervised neural network for binary classification." width="250" height="125" /></a> <p>Results from training a supervised neural network for binary classification. The plot shows the percentage of correctly classified transactions by comparing actual class labels (x-axis) with predicted labels (color; fraud = 1, regular = 0).</p></div></div></div><div><h2>Understanding and trusting machine learning models</h2><p>Decisions made by machine learning models are inherently difficult – if not impossible – for us to understand. The complexity of some of the most accurate classifiers, like neural networks, is what makes them perform so well. But it also basically makes them a black box. This can be problematic, because executives will be less inclined to trust and act on a decision they don’t understand.</p><p>Local Interpretable Model-Agnostic Explanations (LIME) is an attempt to make these complex models at least partly understandable; With LIME, we are able to explain in more concrete terms why, for example, a transaction that was labelled as regular might have been classified as fraudulent. The method has been published in “Why Should I Trust You? Explaining the Predictions of Any Classifier” by Marco Tulio Ribeiro, Sameer Singh and Carlos Guestrin from the University of Washington in Seattle. It makes use of the fact that linear models are easy to explain; LIME approximates a complex model function by locally fitting linear models to permutations of the original training set. On each permutation, a linear model is being fit and weights are given so that positive weights support a decision and negative weights contradict them. In sum, this will give an approximation of how much and in which way each feature contributed to a decision made by the model.</p></div><div><h2>Code</h2><p>A full example with code for training autoencoders and for using LIME can be found on my personal blog:</p><ul><li><a href="https://shiring.github.io/machine_learning/2017/05/01/fraud" target="_blank">Autoencoders and anomaly detection with machine learning Part 1</a>  & <a href="https://shiring.github.io/machine_learning/2017/05/02/fraud_2" target="_blank">Part 2</a> </li><li><a href="https://shiring.github.io/machine_learning/2017/04/23/lime" target="_blank">Explaining complex machine learning models with LIME</a> </li></ul></div>

Data Science for Fraud Detection

<p>Recently, Matthias Radtke has written a very nice blog post on <a href="/wissens-hub/blog/topic-modeling-codecentric-blog-articles">Topic Modeling of the codecentric Blog Articles</a> , where he is giving a comprehensive introduction to Topic Modeling. In this article I am showing a real-world example of how we can use Data Science to gain insights from text data and social network analysis.</p><p>I am using publicly available Twitter data to characterize codecentric’s friends and followers for</p><ul><li>identifying the most “influential” followers and using text analysis tools like sentiment analysis to characterize their interests from their user descriptions</li><li>performing Social Network Analysis on friends, followers and a subset of second degree connections to identify key players who will be able to pass on information to a wide reach of other users and</li><li>combing this network analysis with topic modeling to identify meta-groups with similar interests.</li></ul><p>Knowing the interests and social network positions of our followers allows us to identify key users who are likely to retweet posts that fall within their range of interests and who will reach a wide audience.</p><div><h2>Twitter Mining</h2><p>Via the <a href="https://dev.twitter.com/rest/public" target="_blank">Twitter REST API</a>  anybody can access Tweets, Timelines, Friends and Followers of users or hash-tags. One drawback of the REST API is its rate limit of 15 requests per application per rate limit window (15 minutes). An alternative would be to use <a href="https://dev.twitter.com/streaming/overview" target="_blank">Twitters’s Streaming API</a> , if you wanted to continuously stream data of specific users, topics or hash-tags. Here though, I want to look at a snapshot of codecentric’s Twitter followers to show some of the possibilities that analyzing this information holds.</p><p>On July 15th, codecentric had 449 friends (users who codecentric follows) and 2732 followers (users who follow codecentric), while 261 of them are simultaneously friends & followers.</p><p>We now have the following information about these friends and followers:</p><ul><li>user name</li><li>user screen name</li><li>user description (the short introduction that each user can write about themselves)</li><li>number of tweets per user</li><li>number of followers per user</li><li>number of friends per user</li><li>date of account creation</li><li>account location</li><li>account language</li><li>etc.</li></ul><p>This data can tell us a lot about who is interested in codecentric and what we do. We can e.g. start with a simple exploratory data analysis and look at what languages the accounts are set to – no need for fancy models (just yet)!</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l4v4UecPQSG21djbMRIe"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l4v4UecPQSG21djbMRIe" alt="Grafic Top 10 languages" width="250" height="250" /></a> <p>Top 10 languages of codecentric’s Twitter friends and followers.</p></div><p>As we can see, the vast majority of friends and followers have English and German account settings. The insight derived from this is that tweeting in both, German and English will find an audience among our followers (even though English would probably be more inclusive, assuming that most, if not all, German followers will also be able to understand English tweets).</p><div><h3>Who are codecentric’s most influential followers and what are they interested in?</h3><p>We can also try to identify our most influential followers. These would be followers with a big network (i.e. who have many followers) and who also tweet/re-tweet a lot. If we capture these followers’ interests with one of our tweets, they are a) more likely to re-tweet and b) will reach a bigger audience by doing so!</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QK7SEYRkS0OTZZB0z4OC"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QK7SEYRkS0OTZZB0z4OC" alt="grafic of correlation between follower count and the average number of tweets per day" width="250" height="125" /></a> <p>Correlation between follower count and the average number of tweets per day of codecentric’s Twitter followers.</p></div><p>The plot above shows the correlation between the number of followers codecentric’s followers have and how often they tweet.</p><p>Now that we know who our most influential followers are, we can analyze their short descriptions about themselves to find out what they are interested in. By proxy, this will give us an idea about which kind of tweets are most likely to capture their interest. Of course, this is not to say that these are the only people who (should) matter and that tweets should be tailored towards these interests only! Covering a wide range of topics makes for an interesting and authentic profile but since “knowledge is power”, it can be extremely valuable to know which tweets/posts are likely to increase visibility!</p><p>In order to extract information from the descriptions of the most influential followers (defined as the top 100 followers based on a score of follower count * average tweets per day), I am making use of text analysis and natural language processing tools.</p><p>To prepare the data, I am splitting the user descriptions into words, convert each word to its word stem and remove stop words.</p><p>We can now identify the most common words in these descriptions.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hqTLNoVTq6uR7NGMszYD"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/hqTLNoVTq6uR7NGMszYD" alt="Wordcloud showing most frequently used word stems" width="250" height="250" /></a> <p>Wordcloud showing most frequently used word stems in codecentric’s Twitter followers’ descriptions.</p></div><p>Not surprisingly, software development, agile and business are among the most common words. But also IoT, data and science occur frequently in our influential followers’ descriptions!</p><p>Instead of looking for the most common words, we can also look for the most common word pairs (bigrams).</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l2ha5htMQUCZGz6GjC7o"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/l2ha5htMQUCZGz6GjC7o" alt="grafic of most frequently used word pairs" width="250" height="156" /></a> <p>Most frequently used word pairs in codecentric’s Twitter followers’ descriptions.</p></div><div><p>This graph shows the most common word pairs in our influential followers’ descriptions (arrow colors represent how often the pair occurs). Because we are looking at a relatively small set of followers, none of the word pairs occur exceptionally often. Still, data science is the most common word pair!</p></div><div><h3>Sentiment analysis</h3><p>Sentiment analysis describes a collection of natural language processing tools and resources that are used to identify subjective information in text, like positive or negative sentiment, joy, digust, fear, anger, etc.</p><p>Here, we can also use bigram analysis to identify negated meanings, i.e. words preceded by “not”, “no”, etc. In sentiment analysis, the meanings of negated words can then be reversed.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/RZd8bFxT3GNvjIYWBmJA"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/RZd8bFxT3GNvjIYWBmJA" alt width="250" height="94" /></a> <p>Overall sentiment score distribution of codecentric’s Twitter followers’ descriptions.</p></div><div><div><p>This plot shows the overall sentiment in the user descriptions of the most influential followers. Based on Bing Liu’s sentiment lexicon, we can score how many positive and negative words were used in each followers’ description. Because this lexicon is only available for the English language, we can only get realiable scores for followers with an English description (68 out of 100 followers have an English language setting). As we can see, the majority of followers have predominantly positive descriptions.</p></div></div><div><h2>Social Network Analysis</h2><p>Social networks describe interactions between people, e.g. Twitter friends and followers. The analysis of such networks makes use of graph theory.</p><p>Here, we can show codecentric’s Twitter followers and friends as a directed network: each node represents a user and edge arrows indicate who a user follows.</p><p>Because of Twitter’s API rate limit, I have only mined the friends lists of 106 of codecentric’s friends. Still, this leaves us with a network of 39929 second degree connections!</p><p>With graph theory we can calculate a number of metrics that allow us to identify key players in the network:</p><ul><li>centrality and node degree to find nodes with many adjacent edges (i.e. users who are highly connected)</li><li>closeness to find central nodes (i.e. users that can spread information to many other users)</li><li>transitivity or clustering coefficient, which measures the probability that adjacent nodes are connected</li><li>PageRank or eigenvector centrality, which scores nodes according to their connections with high-degree nodes</li><li>betweenness centrality and diameter (to describe the shortest and longest paths between nodes)</li></ul><p>Below, I am showing the network graph with node size representing betweenness centrality. Nodes with high betweenness centrality are on the path between many other nodes, which makes them key connections or bridges between different groups of nodes. These users are very important because they are likely to pass on information to a wide reach of other users. Node positions are calculated with the Fruchterman-Reingold layout algorithm.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/sGYiXiThSY0Mir9zO0MQ"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/sGYiXiThSY0Mir9zO0MQ" alt="grafic social network of codecentric's Twitter friends and followers" width="250" height="245" /></a> <p>Social network of codecentric’s Twitter friends and followers. Node size represents betweenness centrality.</p></div><h2>Topic Modeling</h2><p>We can now use the follower descriptions again to identify groups of users with similar interests. For a detailed introduction to topic modeling, see <a href="/wissens-hub/blog/topic-modeling-codecentric-blog-articles">Matthias Radtke’s “Topic Modeling of the codecentric Blog Articles”“</a> .</p><p>Here, I am using Latent Dirichlet Allocation with the VEM algorithm to group codecentric’s first and second degree connections into five topics.</p><p>The wordcloud below visualizes the most characteristic words for each topic.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FoH59HV6SVHK5yHUMvAp"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FoH59HV6SVHK5yHUMvAp" alt="Wordcloud showing representative word stems of five topics from topic modelling" width="250" height="250" /></a> <p>Wordcloud showing representative word stems of five topics from topic modelling.</p></div><p>Now, we want to know which topic each user in our network belongs to. This, we can find out with the so called gamma score. Each user is assigned the topic with highest respective gamma score.</p><div><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FHur8dwbS9mWGekhaf7E"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FHur8dwbS9mWGekhaf7E" alt="grafic social network of codecentric's Twitter friends and followers" width="250" height="265" /></a> <p>Social network of codecentric’s Twitter friends and followers. Color indicate topic from topic modelling.</p></div><p>This network shows the different interest groups of codecentric’s Twitter friends based on what topics they and their friends were assigned to (one user e.g. seems to be follow many users assigned to topic 1, which is about software development).</p><p>Even though this network is far from representative, because it only shows a subgroup of second degree friends, we can already see the potential that this information contains! We now have a very good idea about the interests of our friends from a) their Twitter descriptions and b) from the descriptions of the users that they in turn follow. We could now, for example, generate a similar network with first and second degree followers. It would give us a good idea about the interests of users who are not (yet) followers. This information could be used to target specific interest groups by expanding or focusing more on topics where we see a potential for reaching many users via existing followers.</p><p>We could even imagine combining this approach with machine learning techniques to predict follower interests and sharing-potential.</p><hr /><p>All analyses have been done with R version 3.4.0.</p><p>Code is available via <a href="https://github.com/ShirinG/blog_posts_prep/blob/master/twitter/twitter_codecentric.Rmd">Github</a> .</p></div></div></div></div>

Social Network Analysis and Topic Modeling of codecentric’s Twitter friends and followers

<p>Traditional machine learning workflows focus heavily on model training and optimization; the best model is usually chosen via performance measures like accuracy or error and we tend to assume that a model is good enough for deployment if it passes certain thresholds of these performance criteria. <strong>Why</strong> a model makes the predictions it makes, however, is generally neglected. But being able to understand and interpret such models can be immensely important for improving model quality, increasing trust and transparency and for reducing bias. Because complex machine learning models are essentially black boxes and too complicated to understand, we need to use approximations to get a better sense of how they work. One such approach is LIME, which stands for <strong>Local Interpretable Model-agnostic Explanations</strong> and is a tool that helps understand and explain the decisions made by complex machine learning models.</p><div><h2>Accuracy and Error in Machine Learning</h2><p>A general Data Science workflow in machine learning consists of the following steps: gather data, clean and prepare data, train models and choose the best model based on validation and test errors or other performance criteria. Usually we – particularly we Data Scientists or Statisticians who live for numbers, like small errors and high accuracy – tend to stop at this point. Let’s say we found a model that predicted 99% of our test cases correctly. In and of itself, that is a very good performance and we tend to happily present this model to colleagues, team leaders, decision makers or whoever else might be interested in our great model. And finally, we deploy the model into production. We assume that our model is trustworthy, because we have seen it perform well, but we don’t know <strong>why</strong> it performed well.</p><p>In machine learning we generally see a trade-off between accuracy and model complexity: the more complex a model is, the more difficult it will be to explain. A simple linear model is easy to explain because it only considers linear relationships between variables and predictor. But since it only considers linearity, it won’t be able to model more complex relationships and the prediction accuracy on test data will likely be lower. Deep Neural Nets are on the other end of the spectrum: since they are able to deduce multiple levels of abstraction, they are able to model extremely complex relationships and thus achieve very high accuracy. But their complexity also essentially makes them <strong>black boxes</strong>. We are not able to grasp the intricate relationships between all features that lead to the predictions made by the model so we have to use performance criteria, like accuracy and error, as a proxy for how trustworthy we believe the model is.</p><p>Trying to <strong>understand the decisions</strong> made by our seemingly perfect model usually isn’t part of the machine learning workflow.<br /> So why would we want to invest the additional time and effort to understand the model if it’s not technically necessary?</p><p>One way to improve understanding and explain complex machine learning models is to use so-called <em>explainer functions</em>. There are several reasons why, in my opinion, model understanding and explanation should become part of the machine learning workflow with every classification problem:</p><ul><li>model improvement</li><li>trust and transparency</li><li>identifying and preventing bias</li></ul><div><h2>Model Improvement</h2><p>Understanding the relationship between features, classes and predictions, thereby understanding <strong>why</strong> a machine learning model made the decisions it made and which features were most important in that decision can help us decide if it makes <strong>intuitive sense</strong>.</p><p>Let’s consider the following poignant example from the literature: we have a deep neural net that learned to distinguish images of wolves from huskies [1]; it was trained on a number of images and tested on an independent set of images. 90 % of the test images were predicted correctly. We could be happy with that! But what we don’t know without running an explainer function is that the model based its decisions primarily on the background: wolf images usually had a snowy background, while husky images rarely did. So we unwittingly trained a snow detector… Just by looking at performance measures like accuracy, we would not have been able to catch that!</p><p>Having this additional knowledge about how and based on which features model predictions were made, we can intuitively judge whether our model is picking up on meaningful patterns and if it will be able to generalize on new instances.</p></div><div><h2>Trust and Transparency</h2><p>Understanding our machine learning models is also necessary to improve <strong>trust</strong> and provide <strong>transparency</strong> regarding their predictions and decisions. This is especially relevant given the new General Data Protection Regulation (GDPR) that will go into effect in May of 2018. Even though it is still hotly discussed whether its Article 22 includes a “right to explanation” of algorithmically derived decisions [2], it probably won’t be enough for long any more to have black box models making decisions that directly affect people’s lives and livelihoods, like loans [3] or prison sentences [4].</p><p>Another area where trust is particularly critical is medicine; here, decision will potentially have life-or-death consequences for patients. Machine learning models have been impressively accurate at distinguishing malignant from benign tumors of different types. But as basis for (no) medical intervention we still require a professional’s explanation of the diagnosis. Providing the explanation for why a machine learning model classified a certain patient’s tumor as benign or malignant would go a long way to help doctors trust and use machine learning models that support them in their work.</p><p>Even in everyday business, where we are not dealing with quite so dire consequences, a machine learning model can have very serious repercussions if it doesn’t perform as expected. A better understanding of machine learning models can save a lot of time and prevent lost revenue in the long run: if a model doesn’t make sensible decisions, we can catch that <strong>before</strong> it goes into deployment and wreaks havoc there.</p></div><div><h2>Identifying and Preventing Bias</h2><p>Fairness and bias in machine learning models is a widely discussed topic [5, 6]. Biased models often result from biased ground truths: if the data we use to train ours model contains even subtle biases, our models will learn them and thus propagate a self-fulfilling prophecy! One such (in)famous example is the machine learning model that is used to suggest sentence lengths for prisoners, which obviously reflects the inherent bias for racial inequality in the justice system [4]. Other examples are models used for recruiting, which often show the biases our society still harbors in terms of gender-associations with specific jobs, like male software engineers and female nurses [5].</p><p>Machine learning models are a powerful tool in different areas of our life and they will become ever more prevalent. Therefore, it is our responsibility as Data Scientists and decision makers to understand how the models we develop and deploy make their decisions so that we can proactively work on preventing bias from being reinforced and removing it!</p></div><div><h2>LIME</h2><p>LIME stands for <strong>Local Interpretable Model-agnostic Explanations</strong> and is a tool that helps understand and explain the decisions made by complex machine learning models. It has been developed by Marco Ribeiro, Sameer Singh and Carlos Guestrin in 2016 [1] and can be used to explain any classification model, whether it is a Random Forest, Gradient Boosting Tree, Neural Net, etc. And it works on different types of input data, like tabular data (data frames), images or text.</p><p>At its core, LIME follows three concepts:</p><ul><li>explanations are not given globally for the entire machine learning model, but <strong>locally</strong> and for every instance separately</li><li>explanations are given on <strong>original input features</strong>, even though the machine learning model might work on abstractions</li><li>explanations are given for the most important features by <strong>locally fitting a simple model</strong> to the prediction</li></ul><p>This allows us to get an approximate understanding of which features contributed most strongly to a single instance’s classification and which features contradicted it and how they influenced the prediction.</p><p>The following example showcases how LIME can be used:<br /> I built a Random Forest model on a data set about Chronic Kidney Disease [7]. The model was trained to predict whether a patient had chronic kidney disease (ckd) or not (notckd). The model achieved 99 % accuracy on validation data and 95 % on test data. Technically, we could stop here and declare victory. But we want to understand why certain patients were diagnosed with chronic kidney disease and why others weren’t. A medical professional would then be able to assess whether what the model learned makes intuitive sense and can be trusted. To achieve this, we can apply LIME.</p><p>As described above, LIME works on each instance individually and separately. So first, we take one instance (in this case the data from one patient) and <strong>permute</strong> it; i.e. the data is replicated with slight modifications. This generates a new data set consisting of similar instances, based on one original instance. For every instance in this permuted data set we also calculate how similar it is to the original instance, i.e. how strong the modifications made during permutation are. Basically, any type of statistical <strong>distance and similarity metric</strong> can be used in this step, e.g. Euclidean distance converted to similarity with an exponential kernel of specified width.<br /> Next, our complex machine learning model, which was trained before, will <strong>make predictions on every permuted instance</strong>. Because of the small differences in the permuted data set, we can keep track of how these changes affect the predictions that are made.</p><p>And finally, we <strong>fit a simple model</strong> (usually a linear model) to the permuted data and its predictions using the most important features. There are different ways to determine the most important features: we typically define the number of features we want to include in our explanations (usually around 5 to 10) and then either</p><ul><li>choose the features with highest weights in the regression fit on the predictions made by the complex machine learning model</li><li>apply forward selection, where features are added to improve the regression fit on the predictions made by the complex machine learning model</li><li>choose the features with smallest shrinkage on the regularization of a lasso fit on the predictions made by the complex machine learning model</li><li>or fit a decision tree with fewer or equal number of branch splits as the number of features we have chosen</li></ul><p>The similarity between each permuted instance and the original instance feeds as a weight into the simple model so that higher importance is given to instances which are more similar to the original instance. This precludes us from using any simple model as an explainer that is able to take weighted input, e.g. a ridge regression.</p><p>Now, we can interpret the prediction made for the original instance. With the example model described above, you can see the LIME output for the eight most important features for six patients/instances in the figure below:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/W5QkE6LHTSStR5kOMhI9"><img width="250" height="309" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/W5QkE6LHTSStR5kOMhI9" alt="LIME explanations of example machine learning model" /></a> </p><p>Each of the six facets shows the explanation for the prediction of an individual patient or instance. The header of each facet gives the case number (here the patient ID), which class label was predicted and with what probability. For example, the top left instance describes case number 4 which was classified as “ckd” with 98 % probability. Below the header we find a bar-plot for the top 8 most important features; the length of each bar shows the weight of the feature, positive weights support a prediction, negative weights contradict it. Again described for the top left instance: the bar-plot shows that the hemoglobin value was between 0.388 and 0.466, which supports the classification as “ckd”; packed cell volume (pcv), serum creatinine (sc), etc. similarly support the classification as “ckd” (for a full list of feature abbreviations, see <a href="http://archive.ics.uci.edu/ml/datasets/Chronic_Kidney_Disease">http://archive.ics.uci.edu/ml/datasets/Chronic_Kidney_Disease</a> ). This patient’s age and white blood cell count (wbcc), on the other hand, are more characteristic of a healthy person and therefore contradict the classification as “ckd”.</p></div><div><h2>Links and additional resources</h2><ol><li>Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. 2016. “Why Should I Trust You?”: Explaining the Predictions of Any Classifier. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD ’16). ACM, New York, NY, USA, 1135-1144. DOI: <a href="https://doi.org/10.1145/2939672.2939778">https://doi.org/10.1145/2939672.2939778</a> </li><li>Edwards, Lilian and Veale, Michael, Slave to the Algorithm? Why a ‘Right to an Explanation’ Is Probably Not the Remedy You Are Looking For (May 23, 2017). 16 Duke Law & Technology Review 18 (2017). Available at SSRN: <a href="https://ssrn.com/abstract=2972855">https://ssrn.com/abstract=2972855</a> </li><li>http://www.insidertradings.org/2017/12/18/machine-learning-as-a-service-market-research-report-2017-to-2022/</li><li><a href="http://mitsloan.mit.edu/newsroom/press-releases/mit-sloan-professor-uses-machine-learning-to-design-crime-prediction-models/">http://mitsloan.mit.edu/newsroom/press-releases/mit-sloan-professor-uses-machine-learning-to-design-crime-prediction-models/</a>  and <a href="https://www.nytimes.com/2017/05/01/us/politics/sent-to-prison-by-a-software-programs-secret-algorithms.html">https://www.nytimes.com/2017/05/01/us/politics/sent-to-prison-by-a-software-programs-secret-algorithms.html</a> </li><li><a href="https://www.bloomberg.com/news/articles/2017-12-04/researchers-combat-gender-and-racial-bias-in-artificial-intelligence">https://www.bloomberg.com/news/articles/2017-12-04/researchers-combat-gender-and-racial-bias-in-artificial-intelligence</a> </li><li><a href="https://www.engadget.com/2017/12/21/algorithmic-bias-in-2018/">https://www.engadget.com/2017/12/21/algorithmic-bias-in-2018/</a> </li><li><a href="http://archive.ics.uci.edu/ml/datasets/Chronic_Kidney_Disease">http://archive.ics.uci.edu/ml/datasets/Chronic_Kidney_Disease</a> </li></ol><ul><li>I recently gave a talk about LIME at the Münster Data Science Meetup, you can find my slides from that talk here: <a href="https://shiring.github.io/netlify_images/lime_meetup_slides_wvsh6s.pdf">https://shiring.github.io/netlify_images/lime_meetup_slides_wvsh6s.pdf</a> </li><li>the code for the example analysis below can be found here: <a href="https://shirinsplayground.netlify.com/2017/12/lime_sketchnotes/">https://shirinsplayground.netlify.com/2017/12/lime_sketchnotes/</a> </li><li>open-source Python code for LIME: <a href="https://github.com/marcotcr/lime">https://github.com/marcotcr/lime</a> </li><li>R package for LIME: <a href="https://github.com/thomasp85/lime">https://github.com/thomasp85/lime</a> </li></ul></div></div>

Looking beyond accuracy to improve trust in machine learning

People Lead & Principal Consultant Data/AI

Marketing Managerin

Praktikantin

IT-Consultant

IT Consultant

Data Scientist

<p>Als ich anfing, mich genauer mit GraalVM zu beschäftigen, hatte ich nur eine grobe Vorstellung davon, was sich hinter der Bezeichnung eigentlich verbirgt. Beim Lesen der ersten Artikel zum Thema war ich geradezu verwirrt. Was ist GraalVM denn nun? Ein Ersatz für die HotSpot-JVM? Eine Möglichkeit, nativen Code aus Java zu erzeugen? Eine polyglotte VM? In diesem Artikel werde ich versuchen, einen Überblick über das GraalVM-Universum zu geben.</p><h2>Das GraalVM-Projekt</h2><p>Das GraalVM-Projekt von Oracle ist tatsächlich alles das, was ich in der Einleitung erwähnt habe. Dabei wird die Bezeichnung „GraalVM“ sowohl für das Gesamtprojekt als auch für Bestandteile des Projekts genutzt. Graal steht für „General Recursive Applicative and Algorithmic Language“. Neuerdings hat man sich bei Oracle offenbar darauf geeinigt, konsequent GraalVM statt Graal zu verwenden. Daher werde ich dies im Folgenden auch tun. Die Geschichte des GraalVM-Projekts geht zurück in die Zeit, als Java noch von Sun entwickelt wurde. In den folgenden Abschnitten werden ich die einzelnen Teile etwas genauer erläutern.</p><h2>Grundlagen</h2><p>Java-Quellcode wird zunächst in Bytecode übersetzt und kann dann von einer Java Virtual Machine (JVM) ausgeführt werden. Die JVM-Referenzimplementierung ist die <a href="http://openjdk.java.net/groups/hotspot/" target="_blank">HotSpot-JVM des OpenJDKs</a> . Ohne ins Detail gehen zu wollen, kann die HotSpot-JVM entweder den Bytecode interpretieren oder ihn mit einem Compiler „just in time“ (JIT) in Maschinencode übersetzen. Die JIT-Compiler in der HotSpot-JVM C1 und C2 sind sehr alt, schwer wartbar und in C++ sowie Assembler geschrieben.</p><h2>GraalVM-Compiler</h2><p>Das Fundament für das GraalVM-Projekt wurde mit der <a href="http://openjdk.java.net/groups/hotspot/" target="_blank">Maxine VM</a>  gelegt. Eine Grundlage dieses Forschungsprojekts war es, im Gegensatz zur HotSpot-JVM möglichst sämtlichen Code in Java zu schreiben und nicht in C++. Daraus entstanden ist der GraalVM-Compiler. Dieser kann in zwei Modi verwendet werden: Als Just-in-Time-(JIT-)Compiler als Ersatz für den betagten C2 und als Ahead-of-Time-(AOT-)Compiler in Kombination mit der Substrate VM für die GraalVM-Native-Image-Funktion.</p><h2>GraalVM-Compiler als JIT-Compiler</h2><p>Mit Java 8 wurde das JVM Compiler Interface (JVMCI) eingeführt, um alternative JIT-Compiler in die JVM einbinden zu können. Der GraalVM-Compiler nutzt dieses Interface und bietet dabei viele Vorteile gegenüber den bestehenden JIT-Compilern. Er kann besser optimierten Maschinencode produzieren, was insbesondere Scala-Anwendungen, aber auch Java-Anwendungen beschleunigt. Da der Compiler in Java geschrieben ist, muss man bei der Entwicklung nicht mehr zwischen zwei verschiedenen Welten (C++ und Java) springen. Außerdem kann der Compiler sich selbst optimieren, da er auch nur eine Java-Anwendung ist. Letzteres hat den Nachteil, dass das „Aufwärmen“ einer Anwendung ggf. länger dauern kann, da der GraalVM-Compiler sich erst selbst optimieren muss, bis er eine hohe Leistung erreicht. Aus diesem Grund wurde mit Hilfe der GraalVM Native Image-Funktion eine vorkompilierte Version des Compilers namens „libgraal“ geschaffen. Um die Vorteile des GraalVM-Compilers nutzen zu können, muss man sich nur die GraalVM-Distribution herunterladen und anstelle der HotSpot-JVM einsetzen.</p><h2>GraalVM Native Image</h2><p>Durch den Einsatz des GraalVM-Compilers als JIT-Compiler kann die maximale Leistung von JVM-Anwendungen erhöht werden. Das ist insbesondere für langlaufende Serveranwendungen gut. Kurzlebige Anwendungen leiden dagegen unter der langen Startzeit und der hohen Speicherauslastung der JVM. Hier setzt die GraalVM-Native-Image-Funktion an. Mithilfe des GraalVM-Compilers wird dabei vor der Ausführung der Anwendung („ahead of time“) eine nativ ausführbare Datei erstellt, ein sogenanntes „Native Image“. Da zur Laufzeit trotzdem Komponenten wie Garbage Collector und Thread Scheduler benötigt werden, wird die sogenannte Substrate VM eingebunden, die diese Laufzeitkomponenten bereitstellt. Native Images haben im Vergleich zu einer JVM deutlich kürzere Startzeiten und niedrigeren Speicherverbrauch. Dafür ist die maximale Leistung (noch) nicht so hoch, da zugunsten der kürzeren Startzeiten auf einige adaptive Laufzeitoptimierungen verzichtet wird. Außerdem gibt es Einschränkungen bei der Entwicklung von Anwendungen, die zu einem Native Image kompiliert werden sollen, z.B. bei der Verwendung von Reflection.</p><h2>Polyglotte VM</h2><p>Neben dem GraalVM-Compiler und der Native Image-Funktionalität bietet sich GraalVM mithilfe des Truffle-Frameworks außerdem als Laufzeitumgebung für interpretierte Sprachen an. Truffle ermöglicht es, aus einem Interpreter einen hoch-performanten Compiler zu generieren. Aktuell ist es möglich, Anwendungen für Node.js, Ruby, R und Python mit der GraalVM auszuführen. Diese können dabei von allen Möglichkeiten der GraalVM profitieren und laufen dadurch teilweise deutlich schneller, als im jeweils besten verfügbaren Interpreter. Des Weiteren lässt sich mit Hilfe von Sulong LLVM-Bitcode in der GraalVM ausführen. Dadurch lassen sich u. a. Programme starten, die in C oder Rust geschrieben wurden. Doch damit nicht genug, bietet GraalVM außerdem die Möglichkeit, verschiedene Sprachen in einer Anwendung zu mischen. Alle Sprachen laufen dabei im gleichen Kontext und so kann man z.B. aus einer JavaScript-Anwendung heraus ohne Overhead direkt Bibliotheken in R oder Python für Data Science oder das Zeichnen von Graphen verwenden.</p><h2>Community und Enterprise Edition</h2><p>GraalVM wird in einer Community und einer Enterprise Edition vertrieben. Die Community Edition lässt sich kostenlos auch in Produktion nutzen. Die Enterprise Edition bietet u. a. weitergehende Optimierungen des GraalVM-Compilers. Zu Test- oder Demozwecken lässt sie sich kostenlos nutzen, lediglich für den Betrieb in Produktion wird eine kostenpflichtige Lizenz benötigt.</p><h2>Aktueller Stand und Ausblick</h2><p>Die GraalVM mit dem GraalVM-Compiler als Ersatz für die HotSpot-JVM ist bereits produktionsreif und wird u. a. erfolgreich von Oracle Cloud Infrastructure Monitoring benutzt. Windows wird bisher allerdings nur experimentell unterstützt.<br /> Die Native-Image-Funktion ist als „<a href="https://docs.oracle.com/en/graalvm/enterprise/19/guide/overview/license/licensing-information.html" target="_blank">Early Adopter Technology</a> “ gekennzeichnet. Frameworks wie <a href="https://quarkus.io/" target="_blank">Quarkus</a> , <a href="https://micronaut.io/" target="_blank">Micronaut</a>  und <a href="https://helidon.io/" target="_blank">Helidon</a>  unterstützen sie aber schon. <a href="https://github.com/spring-projects/spring-framework/wiki/GraalVM-native-image-support" target="_blank">Spring arbeitet an der Unterstützung</a>  und will diese mit Spring 5.3 ausliefern.<br /> Die Unterstützung von Node.js ist offenbar ausgereift, dagegen wird die Unterstützung von Ruby, R und Python noch als experimentell bezeichnet.<br /> Man kann also schon jetzt vom besseren JIT-Compiler profitieren und damit Ressourcen sparen. Durch die Native-Image-Funktion haben Java-Anwendungen das Potential, in Bereiche vorzudringen, in denen Java traditionell Schwächen hat. Durch den geringen Ressourcenverbrauch und die kurzen Startzeiten werden z. B. Ansätze wie Serverless/FaaS auch für Java-Entwickler interessant. Die kommende Unterstützung durch Spring wird sicherlich dazu beitragen. Nicht zuletzt sind die Möglichkeiten durch die Benutzung verschiedener Sprachen riesengroß.</p>

Was ist GraalVM?

Senior Software Engineer

<p>In diesem Artikel erläutern wir unsere IIoT-Lösung zur autonomen, deklarativen Pflanzenzucht. Dieser Artikel ist der zweite in unserer Reihe zu IIoT. Der <a href="/wissens-hub/blog/iiot-product-development-lessons-from-past-projects">erste Artikel</a>  befasste sich mit allgemeinen Fragen und Problemstellungen zum Thema. Pflanzen zu züchten stellt einzigartige Anforderungen an Hardware, Software und die Steuerungslogik. Dies führt auch zu einzigartigen Lösungen. Unsere IIoT-Lösung ist Hardware-agnostisch, erlaubt Reparaturen und Updates in Produktion ohne Stopp und kann kosten- und zeiteffizient auf andere Anforderungen umgerüstet werden. Die Lösung ist dabei nicht auf die Pflanzenzucht beschränkt.</p><p>Vor über 100 Jahren löste das Auto das Pferd als Transportmittel ab. Durch die Mechanisierung des Transportes war der Weg für dessen Elektrifizierung und schließlich Automatisierung geebnet. Dies gipfelt im autonomen Verhalten von Autos, Mähdreschern und Flugzeugen. Ein Pferd zu automatisieren ist schwer, bei einem Automobil ist dies leichter. Auch hier bietet sich zusätzliches Potential zur Automatisierung.</p><h2>Die Landwirtschaft der Zukunft</h2><p>Ähnliches möchten wir mit unseren Kunden für das Züchten von Pflanzen ermöglichen. Felder und Bauern lassen sich schwerlich automatisieren, doch durch den Übergang zu mechanisierten und elektrisierten Anbausystemen ist dieser Weg leicht. Gleichzeitig lässt sich dadurch die Hürde des optimalen „Rezeptes“ angehen, also einer Abfolge von Instruktionen, wann die Pflanze auszusäen, zu bewässern und zu ernten ist. Ideale Wachstumsbedingungen können eingestellt werden und am Ende wählt der Agrarökonom lediglich ein Rezept für eine Pflanze. Dadurch erhält er ein sauberes, sicheres, reproduzierbares Lebensmittel, das auf dem Weltmarkt konkurrieren kann. Seine Arbeit wird vereinfacht auf die Auswahl der Saaten, die Überwachung der Geräte und die Vermarktung seiner Ernte. Alles wird lückenlos automatisiert protokolliert und belegt damit die Qualität und Sicherheit der produzierten Waren. Vor allem im Feld medizinischer Pflanzen ist solch eine lückenlose Überwachung relevant für geeignete Zertifizierung.</p><p>Pflanzen sind lebendig, sie wachsen, blühen und sterben. Sie benötigen u. a. Wasser, Nährstoffe, Wärme, Licht und wechselnde Luft. Sie sind vergleichsweise träge gegenüber Veränderungen ihrer Umwelt. So hat ein Lichtimpuls von wenigen Sekunden hoher Helligkeit nur geringen Einfluss auf die Pflanze. Um höchstmöglichen Ertrag zu erhalten, eignet sich die aeroponische Anbauweise, d. h. die Wurzeln stecken nicht in Erde, sondern befinden sich in Luft und werden mit Nährlösung bedampft. Dadurch werden sowohl Erde als auch Wasser gespart. Allerdings benötigen die Pflanzen mindestens alle fünf Minuten Wasser, da sie sonst regelrecht ersticken. Somit muss unser System zwingend in der Lage sein, die Pflanzen innerhalb von fünf Minuten zu „gießen“.</p><p>Fällt das System länger als fünf Minuten aus, so stirbt also die Pflanze. Dadurch kann ein mehrwöchiger Produktionslauf komplett verloren gehen. Anders als bei einem klassischen IIoT-Projekt, bei dem zum Beispiel eine Produktionsstraße automatisiert wird, ist ein kurzzeitiger Ausfall während der Aufzucht der Pflanze durchaus vergleichbar mit einem Totalschaden. Bei einer klassischen Produktionsstraße hingegen lässt sich häufig problemlos der Betrieb nach einer Störung wieder aufnehmen. Das Zeitfenster für eine Störung bei der Bewässerung der Pflanzen beträgt jedoch maximal die oben genannten fünf Minuten. Daher muss unser System in der Lage sein automatisch, schnell und sicher wieder produktiv zu werden. Das System muss ausfallende Geräte überstehen und flexibel darauf reagieren. Fest einprogrammierte Abfolgen wie in einer normalen speicherprogrammierbaren Steuerung (SPS) würden uns hier einschränken. Dies unterscheidet unser System natürlich deutlich von klassischen SPS-Systemen. Folgend gehen wir auf diese Unterschiede im Detail ein.</p><h2>Der Pflanzen-Thermomix und seine Rezepte</h2><p>Es ergibt sich, dass wir ein flexibles System benötigen. Ein ebenso agiler Entwicklungs- und Prototypisierungsprozess erleichtert es uns, dieses System von Grund auf zu entwerfen. Zusammen mit den Vorgaben unseres Kunden ergeben sich dadurch mehrere Randbedingungen. Zunächst war ein Revolution Pi (RevPi) mit digitalen und analogen Ein- und Ausgängen sowie Modbus- und Ethernetschnittstellen zur Gerätesteuerung vorgegeben. Der RevPi ist ein Industrie-zertifizierter Computer basierend auf dem als Open Source verfügbaren Raspberry Pi Compute Model. Als zentrale Steuereinheit kann er frei programmiert und via USB oder Ethernetschnittstellen gesteuert werden. Wir haben dafür Python genutzt, da wir so schnell verschiedene Prototypen entwickeln und testen konnten. Da keine auf Millisekunden genaue Steuerung benötigt wurde, reichte die Ausführungsgeschwindigkeit auch aus. Die Lösung lässt sich bei Bedarf nach C++, Rust u. a. portieren. In unserem Use Case war die Entwicklungsgeschwindigkeit wichtig und die die Ausführungsgeschwindigkeit mit Python ausreichend.</p><p>Unsere Lösung ist gut vergleichbar mit einem Thermomix für Pflanzen. Wir wählen ein Rezept in einer Weboberfläche aus, bspw. „Feinblättriger Basilikum“, befüllen das Gerät mit den „Zutaten“, also Setzlingen, Wasser und Nährstoffen. Das Gerät startet und nach ein paar Wochen öffnet sich die Tür der Mikroplantage mit den fertig gezüchteten Pflanzen. In der Zwischenzeit bietet uns ein Dashboard Überblicke über das Pflanzenwachstum und den Zustand der Mikroplantage. Die Nutzung und Umrüstung der Anlage benötigt keinen Techniker oder weiteres spezielles Personal und vereinfacht den Betrieb drastisch.</p><p>Das Rezept zeichnet sich durch einen deklarativen Ansatz aus, d. h. auf einer Zeitachse sind Aktionen angegeben, wie bspw. „Schalte Licht an“, „Heize auf 35°C“ oder „Bedampfe mit 10g Wasser“. Dabei ist es unwichtig für das Rezept, wer der Hersteller der konkreten Hardware ist. Wichtig ist lediglich, dass die Mikroplantage innerhalb der Spezifikation auf 35°C aufgeheizt. Vergleichbare Hardware verschiedener Anbieter kann mit wenig Aufwand ausgetauscht werden. Das Rezept kann leicht generiert und verändert werden. Es beinhaltet die Business-Logik. Jede*r Benutzer*in kann das Rezept geeignet anpassen und auf einer Mikroplantage starten. Ein*e Techniker*in ist nicht nötig. Das Rezept kann vor Start validiert werden, sodass unmögliche oder zerstörerische Abläufe nicht in Produktion kommen.</p><p>Damit unterscheidet sich unser System von einer traditionellen SPS, da statt aufwendig fest einprogrammierter Abfolgen ein dynamisches Verhalten umgesetzt wird. Dieser Ansatz ist zwar komplexer und potenziell fehleranfälliger, aber gleichzeitig flexibler gegenüber Änderungen der Umgebung und Anforderung. Das Rezept und die benutzte Hardware können in Produktion verändert werden. Das verringert die Ausfallzeiten und macht unsere Lösung wertvoller für Kunden mit breit gefächerten Anwendungsgebieten, da die Umrüstung der Mikroplantage einfach ist. Im Falle eines Ausfalls ist die Mikroplantage in der Lage, das Rezept nahtlos fortzuführen. Selbst bei einem Ausfall des RevPi ist ein Austausch dieser sowie Wiederaufnahme der Produktion innerhalb von fünf Minuten möglich. So bringt die mit der Flexibilität einhergehende Komplexität direkten Mehrwert und potentielle Fehler werden systematisch und kategorisch abgefedert. Fehler werden protokolliert und können durch Updates auch im laufenden Betrieb vollständig behoben werden. Diese Resilienz ist elementar für die maximal fünf Minuten Ausfallzeit, damit die Pflanzen überleben.</p><h2>Die Software des Pflanzen-Thermomix</h2><p>Softwareseitig besteht unsere Architektur aus drei wesentlichen Komponenten: der Engine, den Regelkreisläufen und den Gerätetreibern. Die Engine kümmert sich um Zeit und fordert Regelkreisläufe auf, die Instruktionen aus dem Rezept zu verarbeiten. Die Engine sieht also nicht die Hardware, sondern lediglich Instruktionen, während die Regelkreisläufe das Rezept nicht sehen. Die Regelkreisläufe werden damit beauftragt, diese Instruktionen umzusetzen, bspw. „Heize auf 35°C“. Sie implementieren die Logik zur Umsetzung, bspw., „Heize über Treiber A, bis Treiber B 35°C anzeigt“. Die Gerätetreiber sind Schnittstellen, die Regelkreisläufe interagieren nicht direkt mit der Hardware. Dadurch sind die Regelkreisläufe in der Lage, verschiedene Hardwareversionen, -hersteller und -szenarien zu bedienen. Fällt der eben genannte Treiber B aus, der die Temperatur misst, so kann nahtlos Treiber C einspringen. Sowohl Treiber B als auch C sind Temperatursensoren, aber Treiber C nutzt einen einfacheren Sensor an einer anderen Position in der Mikroplantage. Daher muss Treiber C anders behandelt werden, was im Regelkreislauf beschrieben ist.</p><p>Ein Regelkreislauf kann dabei unterschiedlich eng mit einer Hardwarekombination gekoppelt sein und lässt sich austauschen, ohne das Rezept anpassen zu müssen. Wenn bspw. ein Hersteller eine Feedbackschleife in der Hardware implementiert und ein anderer nicht, so kann dies im entsprechenden Regelkreislauf gesondert implementiert werden. Bieten beide Hersteller die gleiche Funktionalität, aber sprechen ein anderes Protokoll oder nutzen andere Adressen, werden lediglich andere Gerätetreiber benötigt. Ändert sich von einer Version auf die nächste nur eine Adresse bei gleicher Funktionalität, muss nur die Konfiguration im Treiber angepasst werden. Erst die Gerätetreiber interagieren direkt mit der Hardware. Sie beinhalten die Protokolle und erhalten „SOLL“- und „MESS“-Befehle. Die Gerätetreiber fungieren damit als Hardware Abstraction Layer. Gemeinsamkeiten unter den Treibern können dabei geteilt werden, was die Implementierung neuer Treiber stark beschleunigt.</p><h2>Modulares System</h2><p>Diese Dreiteilung ermöglicht uns eine Separierung von Business-Logik, dem Rezept, sowie der eigentlichen Hardware in den Gerätetreibern. Alles ist flexibel austauschbar, ohne dass andere Elemente angepasst werden müssen. Die Komponenten interagieren über abstrahierte Schnittstellen, sodass auch hier ein Austausch von Komponenten reibungslos abläuft. Diese vorgegebenen Schnittstellen vereinheitlichen die Kommunikation, was uns einen Zugewinn an Flexibilität und Geschwindigkeit bei der Produktentwicklung ermöglicht. Dieses Gesamtpaket stellt die geforderte hohe Verfügbarkeit und Resilienz sicher.</p><p>Die hohe Flexibilität ermöglicht uns, problemlos unsere Lösung auf andere Use Cases und Business-Logiken umzustellen. Im Idealfall muss nur das Rezept angepasst werden, im Extremfall die Business-Logik in den Regelkreisläufen und die Gerätetreiber, während die Architektur, Kommunikation, Resilienzmechanismen und Überwachungssysteme unangetastet funktional bleiben.</p><p>All dies macht unsere Lösung interessant für neuartige Anwendungsfelder, in denen die Anforderungen und Hürden noch nicht bekannt sind. Statt wochen- und monatelang über Anforderungen, Architekturen und ähnliches zu diskutieren, können wir zügig einen Proof of Concept umsetzen und testen. Dadurch kann in Test- und Produktionsumgebungen hypothesengetrieben gearbeitet werden. Anforderungen können so zielgenau getestet und gelöst werden. Sollte sich eine Komponente als unzureichend erweisen, kann sie problemlos ausgetauscht werden, ohne zurück ans Reißbrett zu müssen. Zusammen mit unserem Ansatz sind wir hardware-agnostisch und können eine kosten- und zeiteffiziente Lösung anbieten.</p><h2>Fazit</h2><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/pAVsk1hNRJeOs7oaaep3"><img loading="lazy" width="1024" height="576" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/pAVsk1hNRJeOs7oaaep3" alt="Kräuter wachsen als Beispiel-Pflanzen sehr gut in unserem Prototyp." /><figcaption>Erfolgreicher Kräutergarten.</figcaption></a> </p><p>In diesem zweiten Blogpost unserer Reihe zu IIoT haben wir aufgezeigt, wie das automatisierte Züchten von Pflanzen die Standardlösungen von IIoT in Frage stellt. Kurze und schnelle Feedback- und Entwicklungszyklen beeinflussen die Hardwarewahl, Programmiersprache und Softwarearchitektur. Gleichzeitig gewinnt unser System an Flexibilität und ist damit für breite Anwendungszwecke geeignet. In den folgenden Artikeln gehen wir näher auf die Details unserer technischen Implementierung und Architektur ein.</p>

IIoT mal anders: Rezepte für den Pflanzen-Thermomix

<p>In this article we explain our IIoT solution for autonomous, declarative plant growing. This article is the second in our series on IIoT. The <a href="/wissens-hub/blog/iiot-product-development-lessons-from-past-projects">first article</a>  dealt with general questions and problems about IIoT. Growing plants offers unique requirements for hardware, software, and control logic. This also leads to unique solutions. Our IIoT solution is hardware-agnostic, allows for repairs and updates in production without interruption, and can be converted to other use cases in a cost- and time-efficient way. The solution is not limited to plant growing.</p><p>More than a hundred years ago, the car superseded the horse as the main means of transport. This mechanisation of transport paved the way for its electrification and eventual automation, culminating in the autonomous behaviour of cars, harvesters, and aeroplanes. Automating a horse is hard, automating an automobile is easier. Here, too, there is additional potential for automation.</p><h2>The agriculture of the future</h2><p>We want to enable something similar with our customers for growing plants. Fields and farmers are difficult to automate, but the transition to mechanised and electrified farming systems makes this path easy. At the same time, it allows the obstacle of the optimal “recipe” to be addressed, i. e. a sequence of instructions on when to plant, irrigate, and harvest the crop. Ideal growing conditions can be set and in the end the agricultural economist simply chooses a recipe for a plant. This gives him a clean, safe, reproducible food product that can compete on the world market. His work is simplified to selecting seeds, monitoring equipment and marketing his harvest. Everything is recorded in a completely automated way, proving the quality and safety of the goods produced. Especially in the field of medicinal plants, such seamless monitoring is relevant for appropriate certification.</p><p>Plants are alive, they grow, blossom, and die. They need water, nutrients, warmth, light, and changing air, among other things. They are comparatively inert to changes in their environment. A light impulse of a few seconds of high brightness has only little influence on the plant. In order to obtain the highest possible yield, the aeroponic cultivation method is suitable, i. e., the roots are not covered in soil, but are in air and steamed with nutrient solution. This saves both soil and water. However, the plants need water at least every five minutes, otherwise they literally suffocate. Thus, our system must be able to “water” the plants within five minutes.</p><p>So if the system fails for more than five minutes, the plant dies. This means that a production run lasting several weeks can be completely lost. Unlike in a classic IIoT project, in which, for example, a production line is automated, a short-term failure during the cultivation of plants can be a total loss. With a classic production line, on the other hand, operation can often be resumed without any problems after a malfunction. However, the time window for a malfunction during the irrigation of the plants is at most the five minutes mentioned above. Therefore, our system must be able to automatically, quickly, and safely become productive again. The system must be able to withstand and react flexibly to failed equipment. Fixed programmed sequences like in a normal PLC would limit us here. Of course, this clearly distinguishes our system from classic PLC systems. In the following, we will go into these differences in detail.</p><h2>The plant thermomix and its recipes</h2><p>It turns out that we need a flexible system. An equally agile development and prototyping process simplifies it for us to design this system from scratch. Together with our client’s specifications, this results in several constraints. First, a Revolution Pi (RevPi) with digital and analogue inputs and outputs as well as Modbus and Ethernet interfaces for device control was specified. The RevPi is an industry-certified computer based on the open-source Raspberry Pi Compute Model. As the main control unit, it can be freely programmed and controlled via USB or Ethernet interfaces. We used Python for this because it allowed us to quickly develop and test different prototypes. Since we did not need control with millisecond precision, the execution speed was sufficient. If necessary, the solution can be ported to C++, Rust, and others. In our use case, however, the development speed was important and the execution speed with Python sufficient.</p><p>Our solution is comparable to a thermomix for plants. We select a recipe in a web interface, for example “basil”, fill the device with the “ingredients”, i. e. seedlings, water, and nutrients. The device starts and after a few weeks the door of the micro-plantation opens with the ready-grown plants. In the meantime, a dashboard gives us an overview of the plant growth and the condition of the micro-plantation. The use and conversion of the unit does not require a technician or other special staff and drastically simplifies the operation.</p><p>The recipe is characterised by a declarative approach, i. e. actions are specified on a time axis, such as “switch on light”, “heat to 35°C” or “spray 10 g of water”. It is unimportant for the recipe who the manufacturer of the specific hardware is. The only important thing is that the micro-plantation heats up to 35°C within the specification. Comparable hardware from different suppliers can be exchanged with little effort. The recipe can be easily generated and modified. The recipe contains the business logic. Any user can customise the recipe and start it on a micro-plantation. A technician is not necessary. The recipe can be validated before starting, so that impossible or destructive processes do not go into production.</p><p>This distinguishes our system from a traditional PLC, since dynamic behaviour is implemented instead of hard-coded sequences. This approach is more complex and potentially more error-prone, but at the same time more flexible to changes in the environment and requirement. The recipe and the hardware used can be changed in production. This reduces downtime and makes our solution more valuable to customers for a wide range of applications as it is easy to retool the micro-plantation. In the event of a failure, the micro-plantation is able to continue the recipe seamlessly. Even if the RevPi fails, it can be replaced and production resumed within five minutes. Thus, the complexity that comes with flexibility brings direct added value and potential errors are systematically and categorically mitigated. Errors are logged and can be completely eliminated through updates, even during operation. This resilience is elementary for the maximum five-minute downtime so that the plants survive.</p><h2>The software of the plant thermomix</h2><p>On the software side, our architecture consists of three main components: the engine, the circuits, and the device drivers. The engine takes care of time and asks circuits to process the instructions from the recipe. The engine does not see the hardware, but only instructions, while the circuits do not see the recipe. The circuits are tasked with implementing these instructions, e. g. “heat to 35°C”. They contain the logic for the implementation, e. g., “heat via driver A until driver B indicates 35°C”. The device drivers implement interfaces, providing an abstraction, so the circuits do not interact directly with the hardware. This means that the circuits are able to operate different hardware versions, manufacturers, and scenarios. If the aforementioned driver B, which measures the temperature, fails, driver C can seamlessly step in. Both drivers B and C are temperature sensors, but driver C uses a simpler sensor at a different position in the micro-plantation. Therefore, driver C must be treated differently, which is described in the circuit.</p><p>A circuit can be differently coupled with a hardware combination and can be exchanged without having to adapt the recipe. For example, if one manufacturer implements a feedback loop in the hardware and another does not, this can be implemented separately in the corresponding circuit. If both manufacturers offer the same functionality but speak a different protocol or use different addresses, only different device drivers are required. If only one address changes from one version to the next with the same functionality, only the configuration in the driver must be adapted. Only the device drivers interact directly with the hardware. They contain the protocols and receive “SET” and “GET” commands. The device drivers thus function as a hardware abstraction layer. Similarities among the drivers can be shared, which greatly accelerates the implementation of new drivers.</p><p>These three components allow us to separate business logic, the recipe, and the actual hardware in the device drivers. Everything can be exchanged flexibly without having to adapt other elements. The components interact via abstracted interfaces, so that an exchange of components is as smoothly possible. These predefined interfaces standardise communication, which allows us to gain flexibility and speed in product development. This package as a whole ensures the required high availability and resilience.</p><p>The high flexibility enables us to easily adapt our solution to other use cases and business logic. Ideally, only the recipe needs to be adapted, in extreme cases the business logic in the circuits and the device drivers, while the architecture, communication, resilience mechanisms and monitoring systems remain functional.</p><p>All this makes our solution interesting for novel fields of application where the requirements and hurdles are not yet known. Instead of spending weeks and months discussing requirements, architectures and the like, we can quickly implement and test our proof-of-concept. This allows hypothesis-driven work in test and production environments. Requirements can thus be tested and solved precisely. If a component proves to be insufficient, it can easily be replaced without having to go back to the drawing board. Together with our approach, we are hardware-agnostic and can offer a cost- and time-efficient solution.</p><h2>Conclusion</h2><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/33UUv5q2SpqIHraoncTI"><img loading="lazy" width="1024" height="576" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/33UUv5q2SpqIHraoncTI" alt="Herbs are growing as test plants in our prototype." /><figcaption>A successful herb garden.</figcaption></a> </p><p>In this second blog post of our series on IIoT, we have shown how automated plant growing challenges the standard solutions of IIoT. Short and fast feedback and development cycles influence the hardware choice, programming language, and software architecture. At the same time, our system gains flexibility and is thus suitable for a broad range of use cases. In the following articles, we will go into more detail about our technical implementation and architecture.</p>

A different flavour of IIoT: Recipes for the plant thermomix

<p>In den letzten Jahren ist die Implementierung von Frontends in Form von Single Page Applications (kurz SPA) immer beliebter geworden. Bei Single Page Applications handelt es sich um Webseiten, die auf den Web-Technologien HTML, CSS und vor allem JavaScript aufsetzen. Im Unterschied zu klassischen Webseiten wird allerdings immer dieselbe HTML-Datei ausgeliefert. Der Inhalt einer Seite wird nachträglich per JavaScript gerendert.</p><p>Das Deployment von Single Page Applications geht mit verschiedenen Herausforderungen einher, auf die ich in diesem Blog Post eingehen möchte. Am Ende des Posts stelle ich ein Container-Basis-Image vor, das auf das Deployment von SPAs spezialisiert ist und bei der Bewältigung der genannten Herausforderungen behilflich sein kann.</p><h2>Statischer Einstiegspunkt</h2><p>Bei der Navigation zwischen Inhalten einer SPA wird die Browser-URL üblicherweise mithilfe des <a href="https://developer.mozilla.org/en-US/docs/Web/API/History_API" target="_blank">HTML 5 History API</a>  manipuliert. Wie bereits erwähnt, wird beim Aufruf einer SPA immer dieselbe HTML-Datei an den Browser ausgeliefert. Wenn die URL des Browsers per History API manipuliert ist, kann es allerdings vorkommen, dass nach einem Reload der Seite eine Fehlerseite angezeigt wird. Dies geschieht, weil der Browser den zu aktualisierenden Inhalt beim Webserver der Seite mit der aktuellen Browser-URL abfragt und die angefragte Ressource dort nicht vorhanden ist. Um dies zu verhindern, muss der Webserver so konfiguriert werden, dass auch bei unbekannten Ressourcen die gewünschte <code>index.html</code>-Datei ausgeliefert wird. Ausnahmen sollten unbekannte Ressourcen-URLs mit bestimmten Endungen wie <code>.js</code>, <code>.css</code>, <code>.jpg</code> und <code>.png</code> bilden. In diesen Fällen sollte der Server weiterhin eine Fehlerseite und den Status-Code <em>404</em> statt der <code>index.html</code> zurückliefern. Dieses Verhalten muss im Webserver, der die SPA ausliefert, entsprechend konfiguriert werden.</p><h2>Deployment-Konfiguration</h2><p>Frameworks wie Angular oder React bieten Mechanismen, um die Konfiguration einer Anwendung zur Compile-Zeit anzuwenden. Diese Vorgehensweise hat allerdings den großen Nachteil, dass die Anwendung für jede Deployment-Umgebung neu kompiliert werden muss. Schöner wäre es, den Build einer Anwendung unabhängig vom Deployment durchführen zu können. Webseiten mit dieser Eigenschaft werden auch <a href="https://github.com/ImmutableWebApps/immutablewebapps.github.io/blob/master/README.md" target="_blank">Immutable Web Apps</a>  genannt. Eine Möglichkeit, eine Single Page Application zur Laufzeit zu konfigurieren, ist es, die Konfiguration in eine einfache Skript-Datei auszulagern und diese beim Deployment auszutauschen.</p><div>

```javascript
window.spaConfig = {
  api: 'https://api.example.com'
};
```

</div><p>Skript-Datei mit der Deployment-Konfiguration der SPA</p><p>Es ist wichtig, dass dieses Skript in der <code>index.html</code> vor dem Skript der eigentlichen Anwendung deklariert wird. So kann im Skript der Anwendung davon ausgegangen werden, dass die Konfiguration bereits verfügbar ist.</p><h2>Ressourcen-Caching</h2><p>Die Compiler bzw. Bundler von Single Page Applications erzeugen häufig Ressourcen-Dateien mit Hashes im Datei-Namen (z. B. <code>main.3b7d25e6.js</code> oder <code>style.74ed70bc.css</code>). Wenn sich der Inhalt einer solchen Datei ändert, ändert sich daher auch automatisch deren Name. Ein Client muss so eine Ressource nur einmalig laden und kann diese anschließend beliebig lange im lokalen Cache halten, ohne den Webserver noch einmal nach einer aktuellen Version zu fragen. Das Ausliefern dieser Ressourcen sollte daher möglichst mit dem HTTP-Header <code>cache-control: public, max-age=31536000, immutable</code> erfolgen. Ressourcen ohne einen entsprechenden Hash (wie z. B. die <code>index.html</code> der Webseite) müssen dagegen mit dem Header <code>cache-control: no-store</code> oder <code>cache-control: no-cache, max-age=0</code> ausgeliefert werden. <code>no-store</code> deaktiviert das Caching dieser Ressourcen vollständig, während <code>no-cache, max-age=0</code> nur die Prüfung erzwingt, ob eine im Cache liegende Ressource noch aktuell ist.</p><p>Der Webserver sollte entsprechend so konfiguriert werden, dass der Browser die Ressourcen mit einem Hash im Namen beliebig lange im Cache hält und bei allen anderen Ressourcen das Caching verhindert bzw. eine Revalidierung der im Cache liegenden Ressourcen erzwingt.</p><h2>Security-Header</h2><p>Bei der Auslieferung von Webseiten kann der Server verschiedene Header mitsenden, um die Seite gegen verschiedene Angriffe abzuhärten. Dazu zählt beispielsweise der <em>Content-Security-Policy</em>-Header, der die ungewollte Kommunikation mit anderen HTTP-Servern im Internet unterbinden kann. Des Weiteren kann mit dem <em>Referrer-Policy</em>-Header gesteuert werden, ob bei der Navigation zu anderen Webseiten ein <em>Referrer</em>-Header mitgeschickt werden soll. So kann das Leaken sensibler Seiten-Parameter verhindert werden. Ein weiterer Header, der beim Ausliefern von HTTP-Ressourcen gesetzt werden sollte, ist der <em>X-Content-Type-Options</em>-Header. Über diesen kann das MIME-Type-Sniffing von Browsern unterbunden werden.</p><h2>Basis-Image: Single Page Application Server</h2><p>Single Page Applications lassen sich sehr gut als Container-Anwendung deployen. Als Basis eignet sich ein Nginx-Image, wie es bereits <a href="/wissens-hub/blog/docker-angular-dockerize-app-easily">in einem früheren codecentric-Blogpost für Angular-Anwendungen</a>  gezeigt wurde. Die oben genannten Anforderungen an das Deployment von Single Page Applications können allerdings die Nginx-Konfiguration sehr kompliziert machen. Wir haben daher ein Basis-Image gebaut, das diese Anforderungen bereits erfüllt und besonders die Deployment-Konfiguration sehr vereinfacht. Zu finden ist dieses Image im <a href="https://hub.docker.com/r/codecentric/single-page-application-server" target="_blank">Docker-Hub</a> . Es basiert ebenso auf einem Nginx-Image und wird regelmäßig automatisch aktualisiert.</p><p>Das Image bietet die Möglichkeit, die Anwendung zur Startzeit des Containers zu konfigurieren. Diese Konfiguration kann für unterschiedliche HTTP-Hosts individuell sein, so dass es möglich wird, mit demselben Container unterschiedliche Umgebungen zu bedienen. Die Konfiguration wird in Form von YAML vorgenommen. Das folgende Beispiel soll dies verdeutlichen:</p><div>

```yaml
default:
  spa_config:
    appTitle: "My Default Application"
    endpoints:
      globalApi: "https://api.example.com"
special_host:
  server_names:
    - "special.example.com"
  spa_config:
    appTitle: "My Special Application"
```

</div><p>Beispiel einer <code>spa_config.yaml</code></p><p>Ein mit dieser Konfiguration gestarteter Container wird zwei verschiedene <code>index.html</code>-Dateien und zwei Konfigurationsskripte generieren, die jeweils in die entsprechende <code>index.html</code>-Datei eingebettet werden. (Eine <code>index.html</code>– und Skript-Datei für den Host <code>special.example.com</code> und einmal beide Dateien für alle anderen Hosts.) Das Image konfiguriert den Nginx-Server so, dass anhand des HTTP-Hosts ausgewählt wird, welche <code>index.html</code> Seite tatsächlich ausgeliefert wird.</p><p><img width="547" height="325" title="Auslieferung einer Host-spezifischen index.html und spa_config.js" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vxj4UBIYQzmRB7TfDO4c" alt="Host-spezifische Single Page Application-Skriptdatei" /><br /> Auslieferung einer Host-spezifischen <code>index.html</code> und <code>spa_config.js</code></p><div>

```javascript
var spaConfig = {
  "appTitle": "My Special Application",
  "endpoints": {
    "globalApi": "https://api.example.com"
  }
}
```

</div><p>Skript-Datei für <code>special.example.com</code></p><p>Die Skript-Datei erzeugt im globalen Kontext der Seite eine <code>spaConfig</code>-Variable, welche die Container-spezifischen Einstellungen der Seite enthält. In der eigentlichen JavaScript-Anwendung kann somit beispielsweise über <code>window.spaConfig.endpoints.globalApi</code> ein Endpunkt abgefragt werden, über den die Seite auf ein HTTP-API zugreifen kann.</p><p>Zur Entwicklungszeit einer SPA mit TypeScript ist es notwendig, die Existenz der <code>spaConfig</code>-Variablen im <code>window</code>-Objekt zu deklarieren. Ansonsten wird sich der TypeScript-Compiler darüber beschweren, dass er diese Variable nicht kennt. Dazu sollte eine TypeScript-Declaration-Datei wie die folgende geschrieben werden:</p><div>

```typescript
declare global {
  interface Window {
    spaConfig: {
      appTitle: string;
      endpoints: {
        globalApi: string;
      }
    };
  }
```

</div><p>SpaConfig.d.ts</p><p>Im <a href="https://github.com/codecentric/single-page-application-server/tree/master/examples" target="_blank">GitHub-Repository</a>  zu diesem Basis-Image gibt es Beispiel-Anwendungen mit Angular und React, welche die Verwendung des Images mit dem jeweiligen Framework verdeutlichen.</p><h3>Weitere Features</h3><p>Neben der einfachen Konfiguration der SPA bietet das Image weitere Features, auf die an dieser Stelle kurz eingegangen werden soll. Per Default liefert das Image die Webseite bereits mit einer strengen Content Security Policy (kurz CSP) aus. Auf diese Weise sollen Sicherheitsaspekte wie die Entschärfung von XSS-Attacken bereits früh berücksichtigt werden. Die Endpunkte, die in <code>spaConfig.endpoints</code> zur Konfiguration der SPA aufgelistet werden, werden allerdings direkt freigegeben, so dass die zusätzliche Konfiguration der CSP nicht zu schnell als störend empfunden und im Zweifel ganz deaktiviert wird. Weitere Sicherheitseinstellungen, wie das Verhindern des Referrer-Headers oder das Sniffen von Ressourcen-Content-Typen durch den Browser, sind ebenfalls per Default eingeschaltet, sollten allerdings noch seltener Probleme bereiten.</p><p>Der Nginx-Server wird außerdem bereits so konfiguriert, dass er Ressourcen, mit Hashes im Namen, mit einer langlebigen Cache-Policy ausliefert. Auf diese Weise müssen viele Ressourcen nur einmalig vom Server geladen werden. Eine Revalidierung der Aktualität dieser Ressourcen wird verhindert, da diese nicht notwendig ist.</p><p>Falls eine Webseite unter einem anderen Basis-Pfad verfügbar sein muss, kann beim Starten des Containers die Konfiguration des <code><base></code>-Elements der <code>index.html</code> vorgenommen werden.</p><p>Bestimmte Tags des Basis-Images werden regelmäßig aktualisiert, so dass immer eine aktuelle Nginx-Version eingesetzt werden kann. Um welche Tags es sich dabei handelt, kann der Dokumentation des Images entnommen werden. Die Funktionsfähigkeit des Images wird bei dessen Aktualisierung kontinuierlich mit Integrationstests geprüft, um mögliche Breaking Changes bei der Konfiguration des Nginx-Servers erkennen zu können.</p><h2>Fazit</h2><p>Das Deployment von Single Page Applications ist nicht trivial und hat in der Vergangenheit in praktisch jedem Projekt zu Fragezeichen geführt. In vielen Fällen waren Best Practices bereits bekannt, allerdings wurde der Aufwand, diese umzusetzen, häufig gescheut oder auf später verschoben. Dieser Blogpost konnte hoffentlich einen guten Überblick über die verschiedenen Aspekte von SPA-Deployments geben und mit dem Basis-Image für Container-Deployments auch einen konkreten Lösungs-Ansatz vorstellen, um diesen Herausforderungen zu begegnen.</p><p> </p><p><a href="https://www.codecentric.de/karriere/jobs/agile-frontend-developer?utm_campaign=PeSo%20Blog%20to%20Job&utm_source=cc_blog&utm_medium=display&utm_content=frontend_developer_und_consultant" target="_blank"><img loading="lazy" width="660" height="220" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/MeSdpJl8Q8aPDtPGUlAA" alt="Finde jetzt als Frontend Developer und Consultant deinen Wen in dein neues Team!" /></a> </p><p> </p><p> </p>

Deployment konfigurierbarer Single Page Applications

Zero Trust Azure Identity & Access Architektur

<p>In recent years, the implementation of frontends in the form of Single Page Applications (SPA) has become increasingly popular. Single Page Applications are websites that are based on the web technologies HTML, CSS and, above all, JavaScript. In contrast to classic websites, however, the same HTML file is always delivered. The content of a page is rendered subsequently using JavaScript.</p><p>The deployment of Single Page Applications poses several challenges which I will discuss in this blog post. At the end of the post, I will introduce a container base image that specializes in deploying SPAs and can help overcome said challenges.</p><h2>Static entry point</h2><p>When navigating between content in an SPA, the browser URL is typically manipulated using the <a href="https://developer.mozilla.org/en-US/docs/Web/API/History_API" target="_blank">HTML 5 History API</a> . As mentioned earlier, when an SPA is called, always the same HTML file is delivered to the browser. However, if the browser’s URL is manipulated via History API, it may happen that an error page is displayed after a reload of the page. This happens because the browser requests the content to be updated from the web server of the page with the current browser URL and the requested resource is not available there. To prevent this, the web server must be configured to deliver the requested <code>index.html</code> file even for unknown resources. Exceptions should be unknown resource URLs with specific extensions, such as <code>.js</code>, <code>.css</code>, <code>.jpg</code> and <code>.png</code>. In these cases, the server should continue to return an error page and the status code <em>404</em> instead of the <code>index.html</code>. This behavior must be configured appropriately in the web server that delivers the SPA.</p><h2>Deployment configuration</h2><p>Frameworks such as Angular or React provide mechanisms to apply the configuration of an application at compile time. However, this approach has the major disadvantage that the application has to be recompiled for each deployment environment. It would be nicer to be able to perform the build of an application independently of the deployment. Web pages with this feature are also called <a href="https://github.com/ImmutableWebApps/immutablewebapps.github.io/blob/master/README.md" target="_blank">Immutable Web Apps</a> . One way to configure a Single Page Application at runtime is to dump the configuration to a simple script file and swap it out during deployment.</p><div>

```javascript
window.spaConfig = {
  api: 'https://api.example.com'
};
```

</div><p>Script file with the deployment configuration of the SPA.</p><p>It is important that this script is declared in the <code>index.html</code> before the script of the actual application. This way it can be assumed in the application’s script that the configuration is already available.</p><h2>Resource caching</h2><p>The compilers or bundlers of Single Page Applications often create resource files with hashes in the file name (e.g. <code>main.3b7d25e6.js</code> or <code>style.74ed70bc.css</code>). Therefore, when the content of such a file changes, its name automatically changes as well. A client only has to load such a resource once and can then keep it in the local cache for any length of time without having to ask the web server again for a current version. The delivery of these resources should therefore be done with the HTTP header <code>cache-control: public, max-age=31536000, immutable</code> if possible. Resources without a corresponding hash (such as the <code>index.html</code> of the web page), on the other hand, must be delivered with the <code>cache-control: no-store</code> or <code>cache-control: no-cache, max-age=0</code> header. <code>no-store</code> completely disables caching of these resources, while <code>no-cache, max-age=0</code> only enforces checking whether a cached resource is still up to date.</p><p>The web server should be configured accordingly so that the browser caches resources with a hash in their name for any length of time and prevents caching for all other resources, or forces revalidation of cached resources.</p><h2>Security header</h2><p>When delivering web pages, the server may send along various headers to harden the page against various attacks. These include, for example, the <em>Content-Security-Policy</em> header, which can prevent unwanted communication with other HTTP servers on the Internet. Furthermore, the <em>Referrer-Policy</em> header can be used to control whether a <em>Referrer</em> header should be sent along when navigating to other websites. This can prevent sensitive page parameters from being leaked. Another header that should be set when delivering HTTP resources is the <em>X-Content-Type-Options</em> header. This can be used to prevent MIME type sniffing by browsers.</p><h2>Base image: Single Page Application server</h2><p>Single Page Applications can be deployed very well as container applications. An Nginx image is suitable as a base, as shown <a href="/wissens-hub/blog/docker-angular-dockerize-app-easily">in a previous codecentric blog post for Angular applications</a> . However, the above requirements for deploying Single Page Applications can make Nginx configuration very complicated. We have therefore built a base image that already meets these requirements and especially simplifies the deployment configuration a lot. You can find this image in the <a href="https://hub.docker.com/r/codecentric/single-page-application-server" target="_blank">Docker Hub</a> . It is also based on an Nginx image and is automatically updated on a regular basis.</p><p>The image provides the ability to configure the application at container startup time. This configuration can be an individual one for different HTTP hosts, so it becomes possible to serve different environments with the same container. The configuration is done in the form of YAML. The following example will illustrate this:</p><div>

```yaml
default:
  spa_config:
    appTitle: "My Default Application"
    endpoints:
      globalApi: "https://api.example.com"
special_host:
  server_names:
    - "special.example.com"
  spa_config:
    appTitle: "My Special Application"
```

</div><p>Example of a <code>spa_config.yaml</code>.</p><p>A container started with this configuration will generate two different <code>index.html</code> files and two configuration scripts, each of which will be embedded in the corresponding <code>index.html</code> file. (One <code>index.html</code> and script file for the host <code>special.example.com</code> and once both files for all other hosts). The image configures the Nginx server to select which <code>index.html</code> page is actually delivered based on the HTTP host.</p><p><img width="547" height="325" title="Delivering a host-specific index.html and spa_config.js" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vxj4UBIYQzmRB7TfDO4c" alt="host-specific single page application script file" /><br /> Delivery of a host-specific <code>index.html</code> and <code>spa_config.js</code>.</p><div>

```javascript
var spaConfig = {.
  "appTitle": {"My Special Application",
  "endpoints": {
    "globalApi": "https://api.example.com"
  }
}
```

</div><p>Script file for <code>special.example.com</code>.</p><p>The script file creates a <code>spaConfig</code> variable in the global context of the page, which contains the container-specific settings of the page. Thus, in the actual JavaScript application, <code>window.spaConfig.endpoints.globalApi</code> can be used, for example, to query an endpoint through which the page can access an HTTP API.</p><p>At development time of an SPA using TypeScript, it is necessary to declare the existence of the <code>spaConfig</code> variable in the <code>window</code> object. Otherwise, the TypeScript compiler will complain that it does not know about this variable. To do this, you should write a TypeScript declaration file like the following:</p><div>

```typescript
declare global {
  interface Window {
    spaConfig: {
      appTitle: string;
      endpoints: {
        globalApi: string;
      }
    };
  }
```

</div><p>SpaConfig.d.ts</p><p>In the <a href="https://github.com/codecentric/single-page-application-server/tree/master/examples" target="_blank">GitHub repository</a>  for this base image, there are sample applications using Angular and React that illustrate how to use the image with each framework.</p><h3>More features</h3><p>In addition to the simple configuration of the SPA, the image offers further features that will be briefly discussed here. By default, the image already delivers the website with a strict content security policy (CSP). In this way, security aspects such as the mitigation of XSS attacks are already taken into account at an early stage. However, the endpoints listed in <code>spaConfig.endpoints</code> for configuring the SPA are released directly, so that the additional configuration of the CSP is not perceived as annoying too quickly and, in case of doubt, is deactivated completely. Other security settings, such as preventing the referrer header or the sniffing of resource content types by the browser, are also enabled by default, but should cause even fewer problems.</p><p>The Nginx server is also already configured to deliver resources, with hashes in their names, with a long-lived cache policy. This way, many resources only need to be loaded from the server once. Revalidation of the timeliness of these resources is prevented, as it is not necessary.</p><p>If a web page needs to be available under a different base path, configuration of the <code><base></code> element of the <code>index.html</code> can be done when the container is started.</p><p>Certain tags of the base image are updated regularly, so that the current Nginx version can always be used. The tags involved can be found in the documentation of the image. The functionality of the image is continuously checked with integration tests when it is updated, in order to be able to detect possible breaking changes in the configuration of the Nginx server.</p><h2>Conclusion</h2><p>Deploying Single Page Applications is not trivial and has raised many questions in virtually every project in the past. In many cases best practices were already known. However, the effort to implement them was often avoided or postponed. Hopefully, this blog post provided a good overview of the different aspects of SPA deployments and it also presented a concrete solution approach with the base image for container deployments to meet these challenges.</p>

Deployment of configurable Single Page Applications

Zero Trust Azure Identity & Access Architecture

IT Consultant & Software Engineer

<p>Process Mining schafft Transparenz darüber, was wirklich in Unternehmen geschieht.<br /> Im Prozessmanagement werden die Idealvorstellungen eines Prozesses meist langwierig definiert. In der Praxis ist die Qualität dieser Beschreibungen jedoch oft nicht eindeutig bestimmbar. Es ist zudem häufig unklar, inwieweit der beschriebene Prozess wirklich ausgeführt wird.</p><p>Auf Basis von existierenden Daten in IT-Systemen wird mit Process Mining der reale Prozess automatisiert identifiziert und visualisiert. So können mit diesem neu generierten Prozesswissen Schwachstellen und ungenutzte Potenziale von Geschäftsprozessen aufgedeckt werden.</p><p>Wir stellen Process Mining im Folgenden anhand eines einfachen Beispiels vor. Wir untersuchen den Ablauf von Arbeitsschritten, der zu Zahlungseingängen von Projekten führt. Dabei ist sowohl die Auftragsabwicklung als auch die Rechnungsstellung relevant. Allein mit dem Prozessplan können wir Indizien für Optimierungspotenziale wie beispielsweise einen ineffizienten Abrechnungsprozess aufdecken.</p><p>In diesem Blogpost möchten wir einen schnellen Einstieg in Process Mining mit der Open Source Software bupaR ermöglichen. Dazu geben wir zunächst einen Überblick über den Anwendungsfall und führen sowohl in Process Mining als auch in bupaR ein. Anschließend folgt eine Beschreibung der Vorgehensweise mit bupaR und unsere daraus resultierenden Erkenntnisse.</p><h2>Was ist der Anwendungsfall?</h2><p>Mit Process Mining identifizieren wir, welche Arbeitsschritte in welcher Reihenfolge wirklich erfolgen, bis ein Projektauftrag zu einer eingehenden Zahlung führt. Dazu nutzen wir Daten aus einer Unternehmenssoftware, die Arbeitsschritte zur Angebots- und Rechnungsabwicklung speichert. Die Arbeitsschritte werden in der Vertriebs- und Finanzabteilung durch das Bedienen der Software erzeugt. Jeder Arbeitsschritt ist eine sogenannte Aktivität. Wir beobachten insgesamt folgende <strong>fünf Aktivitäten</strong>:</p><ol><li>Angebot erstellt</li><li>Auftrag erstellt</li><li>Rechnung erstellt</li><li>Fälligkeit erreicht</li><li>Zahlung erhalten</li></ol><p>Die Ausführung der Aktivitäten zu bestimmten Zeitpunkten führt zu Ereignissen (z. B. Rechnung erstellt am 01.02.2020 um 12:01:20). Diese Ereignisse lassen sich einem eindeutigen Merkmal des Projekts zuordnen (z. B. Rechnung erstellt am 01.02.2020 um 12:01:20 für das Projekt „Process Mining“). Die daraus entstehenden <strong>Ereignisdaten</strong> sind demnach ein Tupel</p><ul><li>einer <strong>Identifikationsnummer(ID)</strong>,</li><li>einer <strong>Aktivität</strong> und</li><li>einer <strong>Zeitangabe</strong>.</li></ul><p>Zusätzlich besteht die Möglichkeit, Metadaten wie beispielsweise Standort, Kunde oder Umsatz hinzuzunehmen, um die Analysemöglichkeiten zu erweitern.</p><p>Wir haben unstrukturierte Ereignisdaten aus der Unternehmenssoftware exportiert und mithilfe eines ETL-Tools aufbereitet. Eine Vorverarbeitung der Daten ist meist sinnvoll, um Inkonsistenzen zu beseitigen. So würde frühzeitig auffallen, dass z. B. Verknüpfungen in den Daten fehlen oder Widersprüche vorliegen. Zudem können die Daten dabei in das passende Format transformiert und zu einem Datensatz aggregiert werden. Ziel ist es, einen automatisierten Vorgang zu implementieren, um manuellen Aufwand zu minimieren und dynamische Daten nutzen zu können.</p><h2>Was ist Process Mining?</h2><p>Process Mining rekonstruiert auf Basis von in IT-Systemen gespeicherten Ereignisdaten den Geschäftsprozess. Diese Technik verbindet die klassische Prozessanalyse und Data Mining. Unter Data Mining kann eine systematische Anwendung von Methoden und Algorithmen zur automatisierten Extraktion von Zusammenhängen in Datenmengen verstanden werden.</p><p>Für die Umsetzung von Process Mining existieren eine Vielzahl von Algorithmen, die zur Ermittlung der Prozesse entwickelt wurden. Jeder davon hat das Ziel, den Prozess bestmöglich zu identifizieren und darzustellen. Der erste und wohl bekannteste Algorithmus ist der Alpha Miner. Viele Algorithmen greifen Ideen des ersten Miners auf und entwickeln diese weiter. Der Alpha Miner scannt die Prozessdaten nach bestimmten Mustern und stellt so Verbindungen her. Anhand eines kleinen Beispiels soll diese Vorgehensweise verdeutlicht werden.</p><p>Beispiel: Ein Prozess wird mit der Symbolik <> von einem anderen Prozess abgegrenzt. Die innerhalb eines Prozesses aufeinanderfolgenden Schritte (hier: a, b und c) sind durch Kommata getrennt. Wenn b auf a folgt, a aber nie auf b, dann wird angenommen, dass eine kausale Abhängigkeit zwischen b und a besteht. Die erkannten Muster werden üblicherweise mit einem Pfeil dargestellt.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/uhYUunXqRWm56UekRRCi"><img width="250" height="39" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/uhYUunXqRWm56UekRRCi" alt="Process Mining: Example Miner" /></a> </p><p>Darauf aufbauend werden mit Process Mining, ähnlich wie im klassischen Prozessmanagement, die Prozesse oft in einem Prozessplan dargestellt. Dieser visualisiert die Reihenfolge der Arbeitsschritte in einem Flussdiagramm.</p><p>Darüber hinaus bietet Process Mining viele weitere Möglichkeiten, den Prozess zu analysieren und abzubilden. So können beispielsweise Durchlaufzeiten oder Doppelarbeiten detailliert untersucht werden, um Optimierungspotenziale aufzudecken.</p><h2>Was ist bupaR?</h2><p>bupaR (Business Process Analysis R) ist eine integrierte Suite der Programmiersprache R. Die Open Source Software entstand bei einer ehrenamtlichen Forschung an der Universität Hasselt (BEL), betreut von Gert Janssenswillen (<a href="https://www.bupar.net/" target="_blank">bupaRs Page</a> ).</p><p>Die Suite besteht aktuell aus acht Paketen. Das zentrale und gleichnamige Paket bupaR beinhaltet die Basisfunktionen und ermöglicht Process Mining auf verschiedenen Stufen der Prozessanalyse durchzuführen. Weitere Pakete konzentrieren sich u. a. auf die deskriptive Beschreibung des Prozesses oder auf die Prozessvisualisierung.</p><p>In bupaR werden die Ereignisdaten in Ereignisprotokollen gespeichert. Auf dieser Grundlage entwickelt der Algorithmus in bupaR iterativ die Reihenfolge der Aktivitäten. Es wird zudem sowohl der Apha Miner als auch der Inductive und Heuristic Miner in bupaR unterstützt.</p><p>Process Mining mit bupaR bietet neben der automatischen Erzeugung des Prozessplans weitaus mehr Möglichkeiten, um tiefer in die Prozessanalyse einzusteigen. So können u. a. einzelne Abfolgen von Aktivitäten oder Durchlaufzeiten intensiver untersucht werden.</p><h2>Wie wird bupaR verwendet?</h2><p>Die Anwendung von bupaR erfolgt in der Entwicklungsumgebung RStudio. Bevor das Ereignisprotokoll mit den Ereignisdaten erstellt wird und die Prozessanalyse starten kann, müssen die notwendigen Pakete installiert und geladen werden.</p><p>In unserem Anwendungsfall verwenden wir die Pakete <em>bupaR</em> und <em>processmapR</em> der bupaR Suite und <em>readr</em> zum Einlesen der Daten. Mit dem Laden des Pakets bupaR werden automatisch die verwandten Pakete mitgeladen (hier: <em>processmapR</em>).</p>

```
#Installieren der notwendigen Pakete

install.packages(“readr”)        #Einlesen der Daten
install.packages (“bupaR”)       #Basisfunktionen Process Mining
install.packages (“processmapR”) #Visualisierung des Prozesses
```



```
#Laden der notwendigen Pakete

library(readr)
library(bupaR)
```

<p>Im Rahmen der Vorverarbeitung haben wir die Daten bereits aufbereitet und in eine einheitliche Struktur zusammengeführt. Als Resultat haben wir den in Abbildung 1 dargestellten Datensatz mit den Spalten ID, Aktivität und Zeitangabe erhalten. Wichtig ist, dass die Zeitangabe als Datum formatiert ist.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/m1ktyH5FTDynvwJxM5bN"><img loading="lazy" width="852" height="296" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/m1ktyH5FTDynvwJxM5bN" alt /></a> </p><p>Die aufbereiteten Daten werden mit der entsprechenden Funktion in RStudio eingelesen (hier: <em>read_csv</em> zum Einlesen der CSV-Datei).</p>

```
#Einlesen der Daten

data <- read_csv("Documents/Offer2Cash.csv")
```

<p>Danach überführen wir die Ereignisdaten mit der Funktion <em>simple_eventlog</em> in ein <strong>einfaches Ereignisprotokoll</strong>, welches Process Mining mit nur drei Parametern ermöglicht. Wir weisen dem Ereignisprotokoll die Spalten ID (<em>case_id</em>), Aktivität (<em>activity_id</em>) und Zeitangabe (<em>timestamp</em>) zu.</p>

```
#Erstellen eines einfachen Ereignisprotokolls

eventlog_data <- simple_eventlog(data,
                    case_id ="CaseID",
                      activity_id = "Activity",
                       timestamp = "Timestamp")
```

<p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/EOmnTYpWQ26NlqnFb0CA"><img loading="lazy" width="1462" height="992" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/EOmnTYpWQ26NlqnFb0CA" alt="Process Mining: RStudio Output" /></a> </p><p>Der in Abbildung 2 wiedergegebene Output gibt uns Einblicke in das erzeugte Ereignisprotokoll. Anhand der 2.578 eingelesenen Zeilen hat bupaR 128 unterschiedliche Prozessvarianten und insgesamt 662 Fälle identifiziert. Durch die Zuordnung der Spalten erkennt bupaR die fünf Aktivitäten (<em>Activity</em>) des Datensatzes automatisch. In unserem Anwendungsfall haben wir uns auf den Zeitraum vom 06.06.2019 bis 16.04.2020 beschränkt. Darüber hinaus besteht das Ereignisprotokoll aus vier Spalten mehr als der eingelesene Datensatz. Die Aktivitätsinstanzkennung (<em>activity_instance_id</em>) ermöglicht zusammengehörende Aktivitäten zu verbinden. Dies ist insbesondere dann relevant, wenn verschiedene Stati je Aktivität angegeben werden. So würden beispielsweise die Aktivitäten „Rechnung erstellt – Start“ und „Rechnung erstellt – Beendet“, die sich auf die gleiche Rechnung beziehen, eine identische Kennung erhalten. In unserem Anwendungsfall berücksichtigen wir keine Stati, so dass jede Aktivität eine eigene Kennung erhält. Die Ressourcenkennung (<em>resource-id</em>) bleibt bei der Verwendung eines einfachen Ereignisprotokoll undefiniert, da keine Zuordnung von Ressourcen in der Funktion erfolgt. Eine Ressource könnte beispielsweise ein Mitarbeiter, ein Standort o. ä. sein. Die Lebenszykluskennung (<em>lifecycle_id</em>) bezieht sich ebenfalls auf verschiedene Stati der Aktivitäten und bleibt somit in unserem Beispiel undefiniert. Anhand der Zeitangaben wird die Reihenfolge (<em>order</em>) von Aktivitäten in bupaR automatisch ermittelt.</p><p>Anschließend starten wir mit der <strong>Entdeckung des Prozesses</strong>. In unserem Anwendungsfall beschränken wir uns auf die Erstellung des Prozessplans. Mit der Funktion <em>process_map</em> wird die Reihenfolge der Aktivitäten automatisiert in einem Prozessplan visualisiert. In der Standardeinstellung werden alle Prozessvarianten dargestellt, sowie die Aktivitäten und Pfeile mit absoluten Häufigkeiten annotiert. Um sich weitere Versionen des Prozessplans ausgeben zu lassen, kann das sogenannte Frequenzprofil (<em>frequency</em>) und Performanceprofil (<em>performance</em>) angepasst werden.</p><p>Zunächst lassen wir uns den am <strong>häufigsten vorkommenden Prozess</strong> angeben. Dazu nutzen wir die Filterfunktion des Frequenzprofils (<em>filter_trace_frequency</em>). In diesem Fall lassen wir uns die häufigsten vorkommenden Prozessvariationen anzeigen bis 1 % aller Prozessvarianten erreicht ist.</p>

```
#Erstellen des am häufigsten vorkommenden Prozesses

eventlog_data %>%
 filter_trace_frequency(perc = 0.01) %>%
  process_map()
```

<p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/1U1phapERyCFw7kz0EY7"><img loading="lazy" width="1286" height="396" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/1U1phapERyCFw7kz0EY7" alt="Process Mining: Most common path" /></a> </p><p>In Abbildung 3 können wir anhand des Prozessplans erkennen, dass der häufigste vorkommende Prozess aus drei Aktivitäten besteht. In 105 Fällen beginnt der Prozess mit der Rechnungsstellung. Bevor die Zahlung eingeht, wird die Zahlungsfrist überschritten.</p><p>Mit der Änderung des Frequenzprofils erhalten wir weitere Informationen über den Prozess und erstellen einen <strong>erweiterten Prozessplan</strong>. Wir lassen uns mit der Filterfunktion bis zu 70 % der Prozessvarianten anzeigen. Zusätzlich ändern wir die Kommentierung der ausgehenden Verbindungspfeile je Aktivität (<em>type_edges</em>) zu relativen Häufigkeiten.</p>

```
#Erstellen des erweiterten Prozessplans

eventlog_data %>%
 filter_trace_frequency(perc = 0.7) %>%
  process_map(type_edges = frequency("relative"))
```

<p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/6LDSKaOS6q847ZBgZpAP"><img loading="lazy" width="996" height="396" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/6LDSKaOS6q847ZBgZpAP" alt /></a> </p><p>Der erweiterter Prozessplan in Abbildung 4 liefert uns Informationen darüber, dass (nur) in 40 % der Fälle die Rechnungserstellung die erste Aktivität ist. Alternativ startet der Prozess mit der Erstellung des Auftrags oder Angebots. In der Regel startet ein Projekt mit einem Angebot und anschließendem Auftrag bevor erstmalig eine Rechnung erstellt wird. Die Angebots- und/oder Auftragserstellung liegt in den Fällen, die nicht mit dieser Reihenfolge starten, vermutlich vor dem gewählten Zeitraum. So ist eine Rückwärtssuche für diese Fälle sinnvoll, d. h. die Daten für die betreffenden Projekte werden um die Aktivitäten Angebotserstellung und ggf. Auftragserstellung mit den jeweiligen Zeitangaben ergänzt. Außerdem beobachten wir, dass in 41 % der Aufträge noch keine Rechnung erstellt ist und von den erstellten Rechnungen in 50 % die Zahlungsfrist überschritten wird. Darüber hinaus stellen wir fest, dass sogar Fälle vorkommen, in denen die Zahlung vor Fakturierung der Leistung eingeht.</p><p>Zusätzlich zum Frequenzprofil kann das Performanceprofil eingestellt werden. Wir erstellen einen <strong>Prozessplan mit Durchlaufzeiten</strong> und lassen uns die durchschnittliche Zeit je aufeinanderfolgende Aktivität in Tagen ausgeben. Diesmal geben wir die relativen Häufigkeiten je Aktivität (<em>type_nodes</em>) in Bezug auf die Gesamtzahl der Fälle an.</p>

```
#Erstellen des Prozessplans mit Durchlaufzeiten

eventlog_data %>%
 filter_trace_frequency(perc = 0.7) %>%
  process_map(type_nodes = frequency("relative"),
   type_edges = performance(mean, "days"))
```

<p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/gLLStoCoTcqzwmoWwwow"><img loading="lazy" width="1286" height="396" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/gLLStoCoTcqzwmoWwwow" alt="Process Mining: Process Map Througput Time" /></a> </p><p>Mit der Hinzunahme des Performanceprofils entnehmen wir dem Prozessplan in Abbildung 5, dass die Dauer zwischen der Auftrags- und Angebotserstellung im Durchschnitt 19 Tage beträgt. Zudem fällt auf, dass sofern die Zahlungsfrist der Rechnung überschritten wird, die Zahlungen durchschnittlich weitere 11 Tage später verbucht werden. Gehen die Einnahme vor der Rechnungsstellung ein, beträgt die Bearbeitungszeit im Durchschnitt 26 Tage.</p><h2>Was sind unsere Erkenntnisse?</h2><p>Process Mining mit bupaR ermöglicht, mit einfachen Ereignisdaten und einem Bruchteil der Analysemöglichkeiten bisher unbekannte Erkenntnisse über den Prozess zu erhalten. So kann die Qualität bestehender Prozessbeschreibungen überprüft oder sogar die langwierige Definition von Prozessen ersetzt werden. Wir haben mithilfe des Frequenzen- und Performanceprofils drei verschiedenen Prozesspläne erstellt. Anhand dieser haben wir die tatsächliche Reihenfolge der Aktivitäten von Projektangebot bis Zahlungseingang ausfindig gemacht.</p><p>Wir haben festgestellt, dass bei einer Vielzahl der Rechnungen die Zahlungsfrist überschritten wird. Diese Information kann uns Aufschluss über die Zahlungsbereitschaft der Kunden geben und auf mögliche Liquiditätsengpässe hindeuten.</p><p>Zudem haben wir erkannt, dass zu bestehenden Aufträge noch keine Rechnung erstellt wurde. Dies kann zur Folge haben, dass zustehende Einnahmen nicht beansprucht werden.</p><p>Darüber hinaus beobachten wir, dass zum Teil Zahlungen vor der Rechnungsstellung eingehen. Dies kann ein Indiz dafür sein, dass der Abrechnungsprozess nicht effizient ist.</p><p>Insgesamt lässt sich sagen, dass Process Mining mit bupaR bereits mit wenig Aufwand realisierbar ist. Die Open Source Software bupaR bietet umfangreiche Möglichkeiten, um Process Mining kostengünstig zu verproben.</p><h4>Wir haben Ihre Neugierde an den Möglichkeiten von Process Mining geweckt? Kontaktieren Sie uns für ein unverbindliches Erstgespräch direkt.</h4>

Process Mining mit bupaR

Product Owner & Agile Coach

Natural Language Processing - Einsteigen und loslegen!

<p>Named entity recognition is a technical term for a solution to a key <strong>automation problem</strong>: <strong>extraction of information from text</strong>. Applications include</p><ul><li>automation of business processes involving documents</li><li>distillation of data from the web by scraping websites</li><li>indexing document collections for scientific, investigative, or economic purposes</li></ul><p>Some cases can be treated by <strong>classical approaches</strong>, for example:</p><ul><li>forms with a fixed structure can be handled by layout-based rules</li><li>entities with fixed pattern like phone numbers can be extracted using regular expressions</li><li>occurrences of known entities like invoice numbers or customer names can be detected by matching against a database</li></ul><p>But when more flexibility is needed, <strong>named entity recognition (NER)</strong> may be just the right tool for the task. In a sequence of blog posts, we will <strong>explain and compare three approaches</strong> to extract references to laws and verdicts from court decisions:</p><ol><li>First, we use the popular NLP library <a href="https://spacy.io" target="_blank">spaCy</a>  and train a custom NER model on the <strong>command line</strong> with no fuzz.</li><li>Next, we build a bidirectional word-level LSTM model <strong>by hand</strong> with <strong><a href="https://www.tensorflow.org" target="_blank">TensorFlow & Keras</a> </strong>.</li><li>Finally, we fine-tune a pre-trained BERT model using <strong><a href="https://huggingface.co" target="_blank">huggingface</a> </strong> <strong><a href="https://huggingface.co/transformers/" target="_blank"> transformers</a> </strong> for <strong>state-of-the-art performance</strong> on the task.</li></ol><p>This post introduces the dataset and task and covers the command line approach using <a href="https://spacy.io" target="_blank">spaCy</a> .</p><h2>Our dataset and task</h2><p>The dataset for our task was presented by E. Leitner, G. Rehm and J. Moreno-Schneider in</p><blockquote><p><strong><a href="https://link.springer.com/chapter/10.1007/978-3-030-33220-4_20" target="_blank">Fine-grained Named Entity Recognition in Legal Documents.</a> </strong></p></blockquote><p>and can be found on <a href="https://github.com/elenanereiss/Legal-Entity-Recognition" target="_blank">GitHub</a> . It consists of decisions from several German federal courts with annotations of entities referring to legal norms, court decisions, legal literature, and others of the following form:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/d7I7DUFTkWhgr1J55GnQ"><img width="700" height="323" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/d7I7DUFTkWhgr1J55GnQ" alt="named entity recognition" /></a> </p><p>The entire dataset comprises 66,723 sentences. We pick</p><ul><li>court decisions of the Federal Labour Court (BAG) for <strong>training</strong> and</li><li>court decisions of the Federal Court of Justice (BGH) for <strong>validation</strong>.</li></ul><p>The following histograms show the distribution of sentence lengths and token annotations for this slice, where ‘O’ denotes the “empty” annotation:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QnaNK89NScmFsLmeixWh"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/QnaNK89NScmFsLmeixWh" alt="data distribution" width="1737" height="576" /></a> </p><p>The <strong>NER task</strong> we want to solve is, given sample sentences, to annotate each token of each sentence with a tag which indicates whether this token is part of a reference to a legal norm, court decision, legal literature, and so on. Put differently, this is a <strong>sequence-labeling task</strong> where we <strong>classify each token</strong> as belonging to one or none annotation class.</p><h2>Enter the NLP library spaCy</h2><p>The Python library <a href="https://spacy.io" target="_blank">spaCy</a>  provides <em><strong>“industrial-strength natural language processing”</strong></em> covering</p><ul><li><strong>15 languages</strong> with small-, medium- or large-scale language models</li><li>the <strong>full NLP pipeline</strong> starting with tokenization over word embeddings to part-of-speech tagging and parsing</li><li>many NLP <strong>tasks</strong> like classification, similarity estimation or named entity recognition</li></ul><p>We now show how to use it for our NER task <strong>with no knowledge</strong> of <strong>deep learning</strong> nor <strong>NLP</strong>.</p><p>Get your keyboard ready!</p><h2>Step 0: Setup</h2><p>To experiment along, you need Python 3. Fire up a terminal to work on the command line, create a folder for this experiment, switch to this folder and create and activate a <a href="https://docs.python.org/3/tutorial/venv.html" target="_blank">virtual environment</a>  with</p><div>

```
python3 -m venv .venv
source .venv/bin/activate

```

</div><p>In case you are on Windows, <a href="https://docs.microsoft.com/de-de/windows/wsl/install-win10" target="_blank">switch</a>  to the Subsystem for Linux or replace the last line by</p><div>

```
.venv\Scripts\activate.bat

```

</div><p>Next, <a href="https://spacy.io/usage#installation" target="_blank">install</a>  spaCy and download the medium-sized <a href="https://spacy.io/models/de">German language model</a>  with</p><div>

```
pip install spacy
python -m spacy download de_core_news_md

```

</div><h2>Step 1: Get the NER data ready</h2><p>The dataset is hosted on <a href="https://github.com/elenanereiss/Legal-Entity-Recognition" target="_blank">GitHub</a>  and contained in one <a href="https://github.com/elenanereiss/Legal-Entity-Recognition/blob/master/data/dataset_courts.zip" target="_blank">zip file</a>  which we download and unzip:</p><div>

```
mkdir -p data/01_raw
curl https://github.com/elenanereiss/Legal-Entity-Recognition/raw/master/data/dataset_courts.zip \
     -L -o data/01_raw/raw.zip
!unzip data/01_raw/raw.zip -d data/01_raw

```

</div><p>Each of the unzipped files contains sample sentences from one court. The sentences come as paragraphs separated by blank lines, with one token and annotation in <a href="https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)" target="_blank">BIO format</a>  per line as follows:</p><div>

```
an O
Kapitalgesellschaften O
( O
§ B-GS
17 I-GS
Abs. I-GS
1 I-GS
und I-GS
2 I-GS
EStG I-GS
) O

```

</div><p>We simply use</p><ul><li>file <code>data/01_raw/bag.conll</code> for training</li><li>file <code>data/01_raw/bgh.conll</code> for validation,</li></ul><p>and convert these files into the format required by <a href="https://spacy.io" target="_blank">spaCy</a> :</p><div>

```
python -m spacy convert --converter ner data/01_raw/bag.conll data/02_train
python -m spacy convert --converter ner data/01_raw/bgh.conll data/03_val

```

</div><p>Along the way, we obtain some status information:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/474DND41RDWMyJNs8vI3"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/474DND41RDWMyJNs8vI3" alt="spaCy preprocessing output" width="700" height="233" /></a> </p><p>To check for potential problems before training, we <strong>check the data</strong> with spaCy’s <a href="https://spacy.io/api/cli#debug-data" target="_blank">debug-data</a>  tool:</p><div>

```bash
python -m spacy debug-data de data/02_train data/03_val -p ner -b de_core_news_md

```

</div><p>which produces the following output:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/i5Qld8gUTFOFptpiFZ8s"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/i5Qld8gUTFOFptpiFZ8s" alt="spaCy data validation output" width="700" height="710" /></a> </p><p>As we have seen before, some tags occur extremely rarely so we can’t expect the model to learn them very well. Moreover, we see that the language model knows almost all words occuring in the dataset, which may come as a surprise.</p><h2>Step 2: Train the NER model</h2><p>To obtain a custom model for our NER task, we use spaCy’s <a href="https://spacy.io/usage/training#ner" target="_blank">train</a>  tool as follows:</p><div>

```
python -m spacy train de data/04_models/md data/02_train data/03_val \
    --base-model de_core_news_md --pipeline 'ner' -R -n 20

```

</div><p>which tells <a href="https://spacy.io" target="_blank">spaCy</a>  to train a new model</p><ul><li>for the German language whose code is <code>de</code></li><li>saving the trained model in <code>data/04_models</code></li><li>using the training and validation data in <code>data/02_train</code> and <code>data/03_val</code>, respectively,</li><li>starting from the base model <code>de_core_news_md</code></li><li>where the task to be trained is <code>ner</code> — named entity recognition</li><li>replacing the standard named entity recognition component via <code>-R</code></li><li>using 20 epochs, that is, 20 runs over the entire training data.</li></ul><p>Depending on your system, training may take several minutes up to a few hours. In case you have an NVidia GPU with CUDA set up, you can try to speed up the training, see spaCy’s <a href="https://spacy.io/usage#gpu" target="_blank">installation</a>  and <a href="https://spacy.io/api/cli#train" target="_blank">training</a>  instructions.</p><p>To track the progress, spaCy displays a table showing the loss (NER loss), precision (NER P), recall (NER R) and F1-score (NER F) reached after each epoch:</p><table><thead><tr><th>Itn</th><th>NER Loss</th><th>NER P</th><th>NER R</th><th>NER F</th><th>Token %</th><th>CPU WPS</th></tr></thead><tbody><tr><td>1</td><td>26507.803</td><td>64.209</td><td>51.197</td><td>56.970</td><td>100.000</td><td>34947</td></tr><tr><td>2</td><td>14681.514</td><td>67.480</td><td>57.931</td><td>62.342</td><td>100.000</td><td>39232</td></tr><tr><td>3</td><td>10907.758</td><td>68.239</td><td>59.384</td><td>63.504</td><td>100.000</td><td>42043</td></tr></tbody></table><p>At the end, <a href="https://spaCy.io" target="_blank">spaCy</a>  tells you that it stored the last and the best model version in <code>data/04_models/model-final</code> and <code>data/04_models/md/model-best</code>, respectively. To check the performance of the model after training, we evaluate it on the validation data:</p><div>

```
python -m spacy evaluate data/04_models/md/model-best data/03_val

```

</div><p>This outputs the precision, recall and F1-score for the NER task again (NER P, NER R, NER F):</p><table><thead><tr><th>Time</th><th>Words</th><th>Words/s</th><th>TOK</th><th>POS</th><th>UAS</th><th>LAS</th><th>NER P</th><th>NER R</th><th>NER F</th><th>Textcat</th></tr></thead><tbody><tr><td>4.37</td><td>177835</td><td>40663</td><td>100.00</td><td>0.00</td><td>0.00</td><td>0.00</td><td>70.15</td><td>60.09</td><td>64.73</td><td>0.00</td></tr></tbody></table><p>The overall performance looks moderate. For better results, one could use</p><ol><li>the large language model <code>de_core_news_lg</code></li><li>more training steps</li><li>more training data (we only used a subset of the dataset).</li></ol><p>As an example, training the large model for 40 epochs yields the following scores:</p><table><thead><tr><th>Time</th><th>Words</th><th>Words/s</th><th>TOK</th><th>POS</th><th>UAS</th><th>LAS</th><th>NER P</th><th>NER R</th><th>NER F</th><th>Textcat</th></tr></thead><tbody><tr><td>4.52</td><td>177835</td><td>39339</td><td>100.00</td><td>0.00</td><td>0.00</td><td>0.00</td><td>73.72</td><td>64.39</td><td>68.74</td><td>0.00</td></tr></tbody></table><p>Apparently, the problem is not the model, but the data: some tag categories appear very rarely so it’s hard for the model learn them. For a more thorough evaluation, we need to see the scores for each tag category.</p><h2>Step 3: Use the model for named entity recognition</h2><p>To use our new model and to see how it performs on each annotation class, we need to use the <a href="https://spacy.io/api" target="_blank">Python API</a>  of <a href="https://spacy.io" target="_blank">spaCy</a> . To experiment along, activate the virtual environment again, install Jupyter and start a notebook with</p><div>

```
pip install jupyter
jupyter notebook spacy_ner.ipynb

```

</div><p>If it did not open by itself, open a web browser pointing to the URL output by the last command, and enter the following Python code blocks in code cells to work along.</p><p>Let us <strong>load</strong> the best-trained model version:</p><div>

```
import spacy
MODEL_PATH = 'data/04_models/md/model-best'
nlp = spacy.load(MODEL_PATH)

```

</div><p>It can be <strong>applied</strong> to detect entities in new text <a href="https://spacy.io/usage/linguistic-features#named-entities-101">as follow</a> :</p><div>

```
sample = """Trotz der zweifelhaften Bewertung von MDMA als "harte Droge"
( vgl. BGH , Beschluss vom 3. Februar 1999 - 5 StR 705/98 ,
juris Rn. 2 ; zum Meinungsstand Patzak in Körner / Patzak / Volkmer
, BtMG , 8. Aufl. , Vorbem. zu §§ 29 ff. Rn. 213 mwN ; Weber , BtMG ,
5. Aufl. , § 1 Rn. 364 mwN ) hat der Strafausspruch Bestand ,
da die verhängte Rechtsfolge jedenfalls angemessen ist 
(§ 354 Abs. 1a Satz 1 StPO) ."""

doc = nlp(sample)

for ent in doc.ents:
    print(ent.label_, ':', ent.text)

```

</div><p>The output looks as follows:</p><div>

```
RS : BGH , Beschluss vom 3. Februar 1999 - 5 StR 705/98 , juris Rn. 2
LIT : Patzak in Körner / Patzak / Volkmer , BtMG , 8.
GS : § 29 ff
GS : Rn
LIT : Weber , BtMG , 5.
GS : § 1 Rn
GS : § 354 Abs. 1a Satz 1 StPO

```

</div><h2>Step 4: Evaluate the model</h2><p>To obtain scores for the model on the level of annotation classes, we continue to work in the Jupyter notebook and load the validation data:</p><div>

```
from spacy.gold import GoldCorpus

VAL_FILENAME = 'data/03_val/bgh.json'

val_corpus = GoldCorpus(VAL_FILENAME, VAL_FILENAME)
docs_golds = list(val_corpus.train_docs(nlp))
docs, golds = zip(*docs_golds)

```

</div><p>To apply our model to these documents, we need to use only the NER component of the model’s NLP pipeline:</p><div>

```python
ner = nlp.pipeline[0][1]
predictions = list(ner.pipe(docs))

```

</div><p>Finally, we can evaluate the performance using the <a href="https://spacy.io/api/scorer" target="_blank"><code>Scorer</code></a>  class. Along the way, we count how often each tag occured:</p><div>

```
from spacy.scorer import Scorer
from collections import Counter

tag_counts = Counter()
scorer = Scorer()
for y_p, y_t in zip(predictions, golds):
    scorer.score(y_p, y_t)
    for tag in y_t.ner:
        tag_counts[tag.split('-')[-1]] += 1
print(scorer.ents_p, scorer.ents_r, scorer.ents_f)

```

</div><p>These are the same scores that we obtained by validating on the command line. Additionally, the <code>ents_per_type</code> attribute of <code>scorer</code> gives us access to the tag-level scores. With pandas installed (<code>pip install pandas</code>), we can put these scores in a table as follows:</p><div>

```
import pandas as pd

scores = (pd.DataFrame.from_dict(scorer.ents_per_type, orient='index')
                      .join(pd.Series(tag_counts, name='support'))
                      .sort_values(by='support', ascending=False))
scores

```

</div><p>For the medium model trained over 20 epochs, we obtain the following result:</p><div><table><thead><tr><th>tag</th><th>p</th><th>r</th><th>f</th><th>support</th></tr></thead><tbody><tr><td>RS</td><td>62.77</td><td>63.34</td><td>63.06</td><td>18615</td></tr><tr><td>GS</td><td>84.93</td><td>84.93</td><td>84.93</td><td>7640</td></tr><tr><td>LIT</td><td>73.70</td><td>83.82</td><td>78.44</td><td>4685</td></tr><tr><td>GRT</td><td>67.88</td><td>32.40</td><td>43.86</td><td>662</td></tr><tr><td>RR</td><td>94.37</td><td>81.03</td><td>87.19</td><td>560</td></tr><tr><td>EUN</td><td>14.28</td><td>7.81</td><td>10.10</td><td>540</td></tr><tr><td>PER</td><td>25.00</td><td>1.62</td><td>3.05</td><td>494</td></tr><tr><td>ORG</td><td>32.25</td><td>28.57</td><td>30.30</td><td>176</td></tr><tr><td>VT</td><td>4.86</td><td>29.16</td><td>8.33</td><td>150</td></tr><tr><td>INN</td><td>33.33</td><td>8.00</td><td>12.90</td><td>124</td></tr><tr><td>UN</td><td>47.61</td><td>16.39</td><td>24.39</td><td>122</td></tr><tr><td>LD</td><td>36.87</td><td>65.82</td><td>47.27</td><td>95</td></tr><tr><td>ST</td><td>28.12</td><td>11.25</td><td>16.07</td><td>85</td></tr><tr><td>VO</td><td>0.00</td><td>0.00</td><td>0.00</td><td>81</td></tr><tr><td>MRK</td><td>0.00</td><td>0.00</td><td>0.00</td><td>58</td></tr><tr><td>AN</td><td>50.00</td><td>1.92</td><td>3.70</td><td>57</td></tr><tr><td>STR</td><td>0.00</td><td>0.00</td><td>0.00</td><td>35</td></tr><tr><td>LDS</td><td>33.33</td><td>10.00</td><td>15.38</td><td>10</td></tr><tr><td>VS</td><td>0.00</td><td>0.00</td><td>0.00</td><td>10</td></tr></tbody></table></div><p>This gives a much clearer picture. Plotting the F1-Score (<code>f</code>) versus the number of tokens with this tag shows a <strong>correlation</strong> between <strong>poor performance</strong> and <strong>shortage of training data</strong>:</p><div><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/S102N7vTT72OCvzEyfn9"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/S102N7vTT72OCvzEyfn9" alt="scatter plot f1-score vs support per tag" width="700" height="467" /></a> </p></div><h2>What next?</h2><p>We’ve seen that spaCy allows us to train a model for extracting information from text with no knowledge of deep learning or NLP with a few commands <strong>on the command line</strong>. The options to improve performance and to adjust the model to our needs are, however, limited. In two following posts, we shall <strong>do better</strong> and</p><ul><li>train a <strong>standard bi-directional LSTM model by hand</strong>, using <strong><a href="https://www.tensorflow.org" target="_blank">TensorFlow & Keras</a> </strong></li><li>train <strong>state-of-the-art transformer models</strong> using <strong><a href="https://huggingface.co" target="_blank">huggingface</a> </strong> <strong><a href="https://huggingface.co/transformers" target="_blank">transformers</a> </strong>.</li></ul><p><em>Stay tuned!</em></p>

NER @ CLI: Custom-named entity recognition with spaCy in four lines

<p>This post shows how to extract information from text documents with the high-level deep learning library <a href="https://keras.io" target="_blank">Keras</a> : we <strong>build, train</strong> and <strong>evaluate</strong> a bidirectional LSTM <strong>model</strong> by hand for a custom <strong>named entity recognition (NER)</strong> task on legal texts.</p><p>In a <a href="/wissens-hub/blog/ner-cli-custom-named-entity-recognition-with-spacy-in-four-lines" target="_blank">previous post</a> , we solved the same NER task on the command line with the NLP library <a href="https://spacy.io" target="_blank">spaCy</a> . The present approach requires some work and knowledge, but yields a much more <strong>flexible solution</strong> which we can tune, scale and modify to our needs.</p><h2>The NER dataset and task</h2><p>We use the <a href="https://github.com/elenanereiss/Legal-Entity-Recognition" target="_blank">dataset</a>  presented by E. Leitner, G. Rehm and J. Moreno-Schneider in</p><blockquote><p><strong><a href="https://link.springer.com/chapter/10.1007/978-3-030-33220-4_20" target="_blank"> Fine-grained Named Entity Recognition in Legal Documents.</a> </strong></p></blockquote><p>again. It consists of decisions from several German federal courts with annotations of named entities referring to legal norms, court decisions, legal literature and others of the following form:</p><figure><div>‘Trotz der zweifelhaften Bewertung von MDMA als ” harte Droge ” ( vgl. <mark> BGH , Beschluss vom 3. Februar 1999 – 5 StR 705/98<br /> , juris Rn. 2 <span> RS</span></mark> ; zum Meinungsstand Patzak in <mark> Körner / Patzak / Volkmer , BtMG , 8. Aufl. , Vorbem. zu §§ 29 ff. Rn. 213 <span> LIT</span></mark> mwN ; <mark> Weber , BtMG , 5. Aufl. , § 1 Rn. 364 <span> LIT</span></mark> mwN ) hat der Strafausspruch<br /> Bestand , da die verhängte Rechtsfolge jedenfalls angemessen ist ( <mark> § 354 Abs. 1a Satz 1 StPO <span> GS</span></mark> ) . ‘</div></figure><p>The task will be to build, train and evaluate a model that, given sample sentences, annotates each token of each sentence with a tag that indicates whether this token is part of a reference to a legal norm, court decision, legal literature and so on.</p><h2>NER with bi-LSTM for dummies</h2><p>We implement a standard deep-learning architecture for NER — a <strong>bi-directional recurrent neural network</strong> — which works as follows:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/gDV23AZGRucsNRL0SNEh"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/gDV23AZGRucsNRL0SNEh" alt="bi-lstm network architecture" width="700" height="368" /></a> </p><ol><li>Each sentence is split into a <strong>sequence of token</strong> and each token is represented by a <strong>word vector</strong>. These <strong>word vectors</strong> or <strong>embeddings</strong> are usually pre-trained on a huge corpus of documents so that they <strong>encode semantic information</strong>. We thus employ general language proficiency to our special task, a technique known as <strong><a href="https://en.wikipedia.org/wiki/Transfer_learning" target="_blank">transfer learning</a> </strong>. Common methods for pre-training are <a href="https://en.wikipedia.org/wiki/Word2vec" target="_blank">word2vec</a> , <a href="https://nlp.stanford.edu/projects/glove/" target="_blank">gloVe</a>  or <a href="https://fasttext.cc/" target="_blank">fasttext</a> ; we use the word vectors provided by <a href="https://spacy.io" target="_blank">spaCy</a> .</li><li>The model processes the input sequence <strong>step by step</strong> and maintains an internal memory along the way,<ul><li><strong>reading</strong> the corresponding <strong>input vector</strong>,</li><li><strong>combining</strong> this input with the <strong>internal memory</strong>,</li><li><strong>producing</strong> an <strong>output vector</strong> and</li><li><strong>updating</strong> the <strong>internal memory</strong></li></ul><p>at each step. This magic is carried out by a <a href="https://en.wikipedia.org/wiki/Long_short-term_memory" target="_blank">long-short-term memory (LSTM) cell</a> . As a result, we obtain an <strong>output sequence</strong> ot the same length as the input sequence, and an internal memory state.</p></li><li>Going <strong>backwards</strong>, the model reads the input again and produces a <strong>second output sequence</strong>.</li><li>At each position, the outputs of steps 2 and 3 are <strong>combined</strong> and <strong>fed into a classifier</strong> which outputs, for the input word at this position, the <strong>probability</strong> that should be annotated with the first tag, second tag, and so on.</li></ol><p>To improve performance, one can replace the last feed-forward layer by a <a href="https://en.wikipedia.org/wiki/Conditional_random_field" target="_blank">conditional random field model (<em>CRF</em>)</a> . The resulting architecture is called <a href="https://arxiv.org/abs/1508.01991" target="_blank"><strong>bi-LSTM-CRF</strong></a>  model.</p><h2>Setting up the environment</h2><p>First, set up a <strong>virtual environment</strong> as described in the <a href="/wissens-hub/blog/ner-cli-custom-named-entity-recognition-with-spacy-in-four-lines#step-0-setup" target="_blank"> preceding blog post</a> , and <strong>install</strong> the required <strong>dependencies</strong>:</p><div>

```
1mkdir keras_ner_project
2cd keras_ner_project
3python3 -m venv .venv
4source .venv/bin/activate
5pip install spacy
6python -m spacy download de_core_news_md
7pip install tensorflow

```

</div><p>Alternatively, follow along with <a href="https://jupyter.org" target="_blank">Jupyter</a>  running inside a <a href="https://www.tensorflow.org/install/docker" target="_blank">TensorFlow Docker container</a> , or with a <a href="https://colab.research.google.com/notebooks/intro.ipynb" target="_blank">google colab notebook</a> .</p><p>Next, <strong>download the data</strong> as in the <a href="/wissens-hub/blog/ner-cli-custom-named-entity-recognition-with-spacy-in-four-lines#step-1-get-the-data-ready" target="_blank"> preceding blog post</a>  (in case you are inside a Jupyter notebook, put an exclamation mark <code>!</code> in front of each command to have it executed by the shell):</p><div>

```
1mkdir -p data/01_raw
2curl https://github.com/elenanereiss/Legal-Entity-Recognition/raw/master/data/dataset_courts.zip \
3     -L -o data/01_raw/raw.zip
4!unzip data/01_raw/raw.zip -d data/01_raw

```

</div><h2>Step 1: Preprocessing for NER</h2><p>The data files contain sample sentences separated by blank lines, with one token and annotation in <a href="https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)" target="_blank"> BIO format</a>  per line as follows:</p><div>

```
 1an O
 2Kapitalgesellschaften O
 3( O
 4§ B-GS
 517 I-GS
 6Abs. I-GS
 71 I-GS
 8und I-GS
 92 I-GS
10EStG I-GS
11) O

```

</div><p>We read such a data file line-by-line and store the sentences as <strong>lists of token-tag pairs</strong>:</p><div>

```
 1def load_data(filename: str):
 2    with open(filename, 'r') as file:
 3        lines = [line[:-1].split() for line in file]
 4    samples, start = [], 0
 5    for end, parts in enumerate(lines):
 6        if not parts:
 7            sample = [(token, tag.split('-')[-1]) for token, tag in lines[start:end]]
 8            samples.append(sample)
 9            start = end + 1
10    if start < end:
11        samples.append(lines[start:end])
12    return samples
13
14train_samples = load_data('data/01_raw/bag.conll')
15val_samples = load_data('data/01_raw/bgh.conll')
16all_samples = train_samples + val_samples

```

</div><p>For simplicity, we’ll <strong>truncate</strong> the sentences to a maximum length and <strong>pad</strong> shorter input sequences. But first, let us determine the set of all tags in the data and add an extra tag for the padding:</p><div>

```
1schema = ['_'] + sorted({tag for sentence in samples for _, tag in sentence})

```

</div><p>Next, we represent each token by a <strong>word vector</strong>, using a pre-trained <a href="https://spacy.io/models/de" target="_blank">German language model</a>  of the NLP library <a href="https://spacy.io" target="_blank">spaCy</a> :</p><div>

```
 1import spacy
 2import numpy as np
 3
 4nlp = spacy.load('de_core_news_md')
 5EMB_DIM = nlp.vocab.vectors_length
 6MAX_LEN = 50
 7
 8def preprocess(samples):
 9    tag_index = {tag: index for index, tag in enumerate(schema)}
10    X = np.zeros((len(samples), MAX_LEN, EMB_DIM), dtype=np.float32)
11    y = np.zeros((len(samples), MAX_LEN), dtype=np.uint8)
12    vocab = nlp.vocab
13    for i, sentence in enumerate(samples):
14        for j, (token, tag) in enumerate(sentence[:MAX_LEN]):
15            X[i, j] = vocab.get_vector(token)
16            y[i,j] = tag_index[tag]
17    return X, y
18
19X_train, y_train = preprocess(train_samples)
20X_val, y_val = preprocess(val_samples)

```

</div><p>Now, we got the data ready for NER and can assemble our model!</p><h2>Step 2: Build the bi-LSTM model</h2><p>With the <a href="https://keras.io/api/layers" target="_blank">wide range</a>  of layers offered by <a href="https://keras.io" target="_blank">Keras</a> , we can can construct a <a href="#dummies" target="_blank">bi-directional LSTM model</a>  as a <strong>sequence of</strong> two compound <strong>layers:</strong></p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/tjofa8hTdWWRt7omP8le"><img loading="lazy" width="700" height="105" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/tjofa8hTdWWRt7omP8le" alt="bi-lstm network layers" /></a> </p><ol><li>The <strong><a href="https://keras.io/api/layers/recurrent_layers/bidirectional/" target="_blank"> bidirectional LSTM</a> </strong> layer encapsulates a forward- and a backward-pass of an <a href="https://keras.io/api/layers/recurrent_layers/lstm/" target="_blank">LSTM</a>  layer, followed by the stacking of the sequences returned by both passes.</li><li>The second layer applies a <a href="https://keras.io/api/layers/core_layers/dense/" target="_blank">dense</a>  <strong>classification layer</strong> to every position of the stacked sequences. Here, the <a href="https://keras.io/api/layers/activation_layers/softmax/" target="_blank">SoftMax<br /> activation</a>  function scales the output so that we obtain sequences of probability distributions:</li></ol><div>

```
 1from tensorflow.keras.models import Sequential
 2from tensorflow.keras.layers import Bidirectional, LSTM, TimeDistributed, Dense
 3
 4def build_model(nr_filters=256):
 5    input_shape = (MAX_LEN, EMB_DIM)
 6    lstm = LSTM(NR_FILTERS, return_sequences=True)
 7    bi_lstm = Bidirectional(lstm, input_shape=input_shape)
 8    tag_classifier = Dense(len(schema), activation='softmax')
 9    sequence_labeller = TimeDistributed(tag_classifier)
10    return Sequential([bi_lstm, sequence_labeller])
11
12model = build_model()

```

</div><p>For <strong>more complex architectures</strong> involving multiple inputs or outputs, residual connections or the like, <a href="https://keras.io" target="_blank">Keras</a>  offers a more flexible <a href="https://keras.io/guides/functional_api/" target="_blank">functional API</a> . With this, we can create <strong>directed acyclic graphs</strong> of tensors connected by applications of layers, and specify a model in terms of its input and output tensors.</p><h2>Step 3: Train the model</h2><p>To train a model means to <strong>optimize its weights or parameters</strong> on data so that the model’s predictions approximate the truth. For Keras to perform this optimization, we need to specify</p><ul><li>how to <strong>measure the distance of the prediction to the truth</strong>, that is, a <strong><a href="https://en.wikipedia.org/wiki/Loss_function" target="_blank">loss function</a> </strong>,</li><li>the <strong>optimization strategy</strong> which is a variant of batch-wise <strong><a href="https://en.wikipedia.org/wiki/Gradient_descent" target="_blank">gradient descent</a> </strong>.</li></ul><p>Additionally, we can specify a <strong>metrics</strong> to <strong>monitor the training progress</strong>. Once this has been done using the <a href="https://keras.io/api/models/model_training_apis/" target="_blank"><code>compile</code> method</a> , we can call the <a href="https://keras.io/api/models/model_training_apis/" target="_blank"><code>fit</code> method</a>  for training:</p><div>

```
 1def train(model, epochs=10, batch_size=32):
 2    model.compile(optimizer='Adam',
 3                  loss='sparse_categorical_crossentropy',
 4                  metrics='accuracy')
 5    history = model.fit(X_train, y_train,
 6                        validation_split=0.2,
 7                        epochs=epochs,
 8                        batch_size=batch_size)
 9    return history.history
10
11history = train(model)

```

</div><p><a href="https://keras.io" target="_blank">Keras</a>  provides implementations of all the standard <a href="https://keras.io/api/optimizers/" target="_blank">optimizers</a> , <a href="https://keras.io/api/losses/" target="_blank">loss functions</a>  and <a href="https://keras.io/api/metrics/" target="_blank">metrics</a> , and also allows us to supply our own.</p><p>The <strong>training history</strong> contains the losses and metrics achieved on the training and validation data after each epoch. Here, I got the following result:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/2J3hPU2ZSnCH59ppol2y"><img loading="lazy" width="700" height="233" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/2J3hPU2ZSnCH59ppol2y" alt="training history" /></a> </p><p>Note the scale on the y-axis, but <strong>don’t get excited by accuracies of 99%</strong>: almost all token are labelled by the trivial tag <code>O</code> and hence accuracy does not tell much about detection of the non-trivial tags.</p><h2>Step 4: Evaluate the model</h2><p>To <strong>assess the performance of the model</strong>, we apply it to the preprocessed validation data and obtain a tensor of the shape <code>(len(val_samples), MAX_LEN, len(schema))</code>. This tensor contains, for each sample sentence and each token in this sentence, a <strong>predicted probability distribution</strong> over the tags. We choose the tag with highest probability and return, for each sentence and each token, the true and the predicted tag:</p><div>

```
1def predict(model):
2    y_probs = model.predict(X_val)
3    y_pred = np.argmax(y_probs, axis=-1)
4    return [
5        [(token, tag, schema[index]) for (token, tag), index in zip(sentence, tag_pred)]
6        for sentence, tag_pred in zip(val_samples, y_pred)
7    ]
8
9predictions = predict(model)

```

</div><p>Finally, we compute <a href="https://en.wikipedia.org/wiki/Precision_and_recall" target="_blank">precision, recall and f1-score</a>  on the level of tag categories using <a href="https://www.scikit-learn.org" target="_blank">scikit learn</a> ’s <a href="https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html" target="_blank"> <code>classification_report</code></a> :</p><div>

```
 1import pandas as pd
 2from sklearn.metrics import classification_report
 3
 4def evaluate(predictions):
 5    y_t = [pos[1] for sentence in predictions for pos in sentence]
 6    y_p = [pos[2] for sentence in predictions for pos in sentence]
 7    report = classification_report(y_t, y_p, output_dict=True)
 8    return pd.DataFrame.from_dict(report).transpose().reset_index()
 9
10evaluate(predictions)

```

</div><p>Training a model with 1024 filters for 10 epochs, we reach the following scores:</p><div><table><thead><tr><th>tag</th><th>f1-score</th><th>precision</th><th>recall</th><th>support</th></tr></thead><tbody><tr><td>EUN</td><td>56.9</td><td>67.0</td><td>49.5</td><td>398</td></tr><tr><td>GRT</td><td>65.9</td><td>91.0</td><td>51.6</td><td>643</td></tr><tr><td>GS</td><td>94.5</td><td>96.1</td><td>92.9</td><td>6774</td></tr><tr><td>INN</td><td>41.3</td><td>88.9</td><td>26.9</td><td>119</td></tr><tr><td>LD</td><td>74.0</td><td>67.0</td><td>82.6</td><td>86</td></tr><tr><td>LDS</td><td>0.0</td><td>0.0</td><td>0.0</td><td>9</td></tr><tr><td>LIT</td><td>79.5</td><td>74.3</td><td>85.4</td><td>1681</td></tr><tr><td>MRK</td><td>0.0</td><td>0.0</td><td>0.0</td><td>49</td></tr><tr><td>ORG</td><td>25.3</td><td>32.4</td><td>20.8</td><td>159</td></tr><tr><td>PER</td><td>0.0</td><td>0.0</td><td>0.0</td><td>473</td></tr><tr><td>RR</td><td>92.0</td><td>94.4</td><td>89.8</td><td>560</td></tr><tr><td>RS</td><td>90.7</td><td>97.1</td><td>85.0</td><td>8380</td></tr><tr><td>ST</td><td>71.9</td><td>93.9</td><td>58.2</td><td>79</td></tr><tr><td>STR</td><td>0.0</td><td>0.0</td><td>0.0</td><td>35</td></tr><tr><td>UN</td><td>32.7</td><td>64.9</td><td>21.8</td><td>110</td></tr><tr><td>VO</td><td>2.2</td><td>4.0</td><td>1.5</td><td>66</td></tr><tr><td>VS</td><td>0.0</td><td>0.0</td><td>0.0</td><td>10</td></tr><tr><td>VT</td><td>18.0</td><td>11.7</td><td>38.9</td><td>144</td></tr></tbody></table></div><p>Let’s see how this compares to the results achieved with <a href="https://spacy.io" target="_blank">spaCy</a> :</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/WJMKOXvcQdmDe0XSe1uA"><img loading="lazy" width="700" height="319" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/WJMKOXvcQdmDe0XSe1uA" alt="f1-scores for spaCy and Keras model" /></a> </p><p>It seems that <strong>our hand-built NER model does very well</strong>! But beware that <strong>these experiments do not show a winner</strong>: neither of the two approaches has been optimized and we did not compare training time nor compute resources used. The <strong>main differentiating factor</strong> is that</p><ul><li>spaCy can be used <strong>out-of-the-box</strong> with no understanding of deep learning</li><li>the approach presented here is much more <strong>flexible</strong> and tuneable (see below).</li></ul><h2>What next?</h2><p>With the deep learning library <a href="https://keras.io" target="_blank">Keras</a> , <strong>build and training</strong> our custom NER model <strong>took just a few lines</strong>, but setting up the data and the training required much <strong>more understanding</strong> than the <a target="_blank">command-line approach</a>  with <a href="https://spacy.io" target="_blank">spaCy</a> .</p><p>To <strong>improve performance</strong>, we could try to <strong>tune the model</strong> and</p><ul><li>increase the number of filters, that is, the size of the LSTM cell,</li><li>stack several bidirectional layers on top of each other,</li><li>replace the time-distributed classification layer with a conditional random field (CRF) model or</li><li>address the imbalance of the tag distribution with a <a href="https://arxiv.org/abs/1708.02002" target="_blank">focal loss</a>  instead of categorical cross-entropy.</li></ul><p>But to achieve a significant boost, we need to provide our model with <strong>more input</strong> by</p><ol><li>labeling more task-specific training data or</li><li>applying more of task-independent <strong>language proficiency</strong> to our task.</li></ol><p>In a next blog post, we shall <strong>fine-tune</strong> a pre-trained NLP <strong>transformer</strong> model to our NER task and get <strong>state-of-the-art performance</strong>.</p><p>Stay tuned!</p>

Take control of named entity recognition with your own Keras model!

<p>How do you solve deep learning problems with <strong>too little labelled data</strong>? The answer, of course, is <strong>transfer learning</strong>. In this post, we will apply this concept to <a href="https://en.wikipedia.org/wiki/Named-entity_recognition" target="_blank">named entity recognition (NER)</a>  and</p><ul><li><strong>fine-tune a pre-trained <a href="https://en.wikipedia.org/wiki/BERT_(language_model)" target="_blank">BERT</a> </strong> to extract information from legal texts,</li><li>encounter a <strong>token misalignment problem</strong> due to BERT’s preference for <strong>sub-word token</strong>, and</li><li>observe <strong>tremendous improvements on difficult classes</strong> compared to the <a>hand-made bi-lstm model</a>  of our previous posts.</li></ul><p>Let’s get started!</p><h2>The NER dataset and task</h2><p>We use the <a href="https://github.com/elenanereiss/Legal-Entity-Recognition" target="_blank">dataset</a>  presented by E. Leitner, G. Rehm and J. Moreno-Schneider in</p><blockquote><p><strong><a href="https://link.springer.com/chapter/10.1007/978-3-030-33220-4_20" target="_blank">Fine-grained Named Entity Recognition in Legal Documents.</a> </strong></p></blockquote><p>again. It consists of German court decisions with annotations of entities referring to legal norms, court decisions, legal literature and so on of the following form:</p><figure><div>‘Trotz der zweifelhaften Bewertung von MDMA als ” harte Droge “( vgl. <mark> BGH , Beschluss vom 3. Februar 1999 – 5 StR 705/98 , juris Rn. 2<span>RS</span></mark>; zum Meinungsstand Patzak in<mark>Körner / Patzak / Volkmer , BtMG , 8. Aufl. , Vorbem. zu §§ 29 ff. Rn. 213<span>LIT</span></mark>mwN ;<mark>Weber , BtMG , 5. Aufl. , § 1 Rn. 364<span>LIT</span></mark>mwN ) hat der Strafausspruch Bestand , da die verhängte Rechtsfolge jedenfalls angemessen ist (<mark>§ 354 Abs. 1a Satz 1 StPO<span>GS</span></mark>) . ‘</div></figure><p>The task for our model will be to annotate, given a sample sentence, each word with a tag that indicates whether this word is part of a reference to legal norm, court decisions and so on. For more details, see the <a>first post</a>  of this series.</p><h2>The transformer revolution</h2><p>In case you haven’t read about transformers, here’s a summary. For details on the the original transformer architecture, see <a href="https://nlp.seas.harvard.edu/2018/04/03/attention.html" target="_blank">the original paper</a>  or <a href="https://nlp.seas.harvard.edu/2018/04/03/attention.html" target="_blank">one</a>  of the <a href="https://towardsdatascience.com/transformers-state-of-the-art-natural-language-processing-1d84c4c7462b" target="_blank">many</a>  <a href="https://www.analyticsvidhya.com/blog/2019/06/understanding-transformers-nlp-state-of-the-art-models/" target="_blank">blog</a>  <a href="http://jalammar.github.io/illustrated-transformer/" target="_blank">posts</a>  on the topic.</p><p>Transformers transformed natural language processing (NLP) with</p><ul><li>a revolutionary <a href="https://nlp.seas.harvard.edu/2018/04/03/attention.html" target="_blank"><strong>attention mechanism</strong></a>  that replaces convolutional or recurrent architectures,</li><li>a shift in <strong>transfer learning</strong> from <em>pre-training (word vectors) for feature extraction</em> to <em>training <a href="https://en.wikipedia.org/wiki/Language_model#Neural_network" target="_blank">generic language models</a> </em> plus <em>fine-tuning on downstream tasks</em>, and</li><li>an <strong>exponential growth of model size</strong> that brought us performance on par with humans on a number of NLP tasks but also <a href="https://arxiv.org/abs/1906.02243" target="_blank">exploding</a>  <a href="https://arxiv.org/abs/2007.03051" target="_blank">resource consumption</a>  with diminishing returns:<img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/MzjsvMT2TnOqMktU6G3v" alt="exponential growth of transformer sizes" width="900" height="709" /></li></ul><p>To leverage transformers for our custom NER task, we’ll use the Python library <a href="https://huggingface.co/transformers" target="_blank">huggingface transformers</a>  which provides</p><ul><li>a <a href="https://huggingface.co/models" target="_blank">model repository</a>  including BERT, GPT-2 and others, pre-trained in a variety of languages,</li><li><a href="https://huggingface.co/transformers/task_summary.html" target="_blank">wrappers for downstream tasks</a>  like classification, named entity recognition, summarization, et cetera and</li><li>convenient ways to <a href="https://huggingface.co/transformers/training.html" target="_blank">fine-tunining on downstream tasks</a> , e.g. in end-to-end pipelines or via <a href="https://www.tensorflow.org" target="_blank">TensorFlow</a>  or <a href="https://pytorch.org" target="_blank">PyTorch</a> .</li></ul><p>Get your keyboard ready or follow along just reading!</p><h2>Setting up the environment</h2><p>Set up a <strong>virtual environment</strong>, <strong>install</strong> the required <strong>dependencies</strong> and <strong>download the dataset</strong> similarly as in the preceding <a href="/wissens-hub/blog/ner-cli-custom-named-entity-recognition-with-spacy-in-four-lines">blog</a>  <a href="/wissens-hub/blog/take-control-of-named-entity-recognition-with-you-own-keras-model">posts</a> :</p><div>

```bash
mkdir transformers_ner_project && cd transformers_ner_project
python3 -m venv .venv && source .venv/bin/activate
pip install numpy pandas tqdm sklearn transformers[tf-cpu]
mkdir -p data/01_raw
curl https://github.com/elenanereiss/Legal-Entity-Recognition/raw/master/data/dataset_courts.zip 
     -L -o data/01_raw/raw.zip
unzip data/01_raw/raw.zip -d data/01_raw

```

</div><p>Alternatively, follow along with <a href="https://jupyter.org" target="_blank">Jupyter</a>  running inside a <a href="https://www.tensorflow.org/install/docker" target="_blank">TensorFlow Docker container</a> , or with a <a href="https://colab.research.google.com/notebooks/intro.ipynb" target="_blank">Google Colab notebook</a> .</p><h2>Step 1: Loading a pre-trained BERT</h2><p>With <a href="https://huggingface.co/transformers" target="_blank">huggingface transformers</a> , it’s super-easy to get a state-of-the-art pre-trained transformer model nicely packaged for our NER task: we choose a <a href="https://huggingface.co/bert-base-german-cased" target="_blank"><strong>pre-trained German BERT model</strong></a>  from the <a href="https://huggingface.co/models" target="_blank">model repository</a>  and request a wrapped variant with an additional <strong>token classification layer</strong> for NER with just a few lines:</p><div>

```python
from transformers import AutoConfig, TFAutoModelForTokenClassification

MODEL_NAME = 'bert-base-german-cased' 

config = AutoConfig.from_pretrained(MODEL_NAME, num_labels=len(schema))
model = TFAutoModelForTokenClassification.from_pretrained(MODEL_NAME, 
                                                          config=config)
model.summary()

```

</div><p>The result is a <a href="https://www.tensorflow.org" target="_blank">TensorFlow</a>  model consisting of the pre-trained BERT transformer, followed by a drop-out and a dense classifier layer which predicts the tag of each token:</p>

```
Model: "tf_bert_for_token_classification"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
bert (TFBERTMainLayer)       multiple                  109081344 
_________________________________________________________________
dropout_37 (Dropout)         multiple                  0         
_________________________________________________________________
classifier (Dense)           multiple                  16149     
=================================================================
Total params: 109,097,493
Trainable params: 109,097,493
Non-trainable params: 0
_________________________________________________________________

```

<h2>Step 2: Preprocessing</h2><p>The data files contain sample sentences separated by blank lines, with one token and annotation in <a href="https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)" target="_blank">BIO format</a>  per line:</p><div>

```bash
an O
Kapitalgesellschaften O
( O
§ B-GS
17 I-GS
Abs. I-GS
1 I-GS
und I-GS
2 I-GS
EStG I-GS
) O

```

</div><p>We read two data files line-by-line, store the sentences as <strong>lists of token-tag pairs</strong>, and determine the <strong>annotation schema</strong> just like we did it for training our <a href="/wissens-hub/blog/take-control-of-named-entity-recognition-with-you-own-keras-model" target="_blank">bi-LSTM model</a> :</p><div>

```python
def load_data(filename: str):
    with open(filename, 'r') as file:
        lines = [line[:-1].split() for line in file]
    samples, start = [], 0
    for end, parts in enumerate(lines):
        if not parts:
            sample = [(token, tag.split('-')[-1]) 
                          for token, tag in lines[start:end]]
            samples.append(sample)
            start = end + 1
    if start < end:
        samples.append(lines[start:end])
    return samples

train_samples = load_data('data/01_raw/bag.conll')
val_samples = load_data('data/01_raw/bgh.conll')
samples = train_samples + val_samples
schema = ['_'] + sorted({tag for sentence in samples 
                             for _, tag in sentence})

```

</div><h2>Gotcha! Sub-word tokenization?</h2><p>But how do we feed the data into our transformer? The answer <strong>depends on the model</strong> that we chose because it has been pre-trained with a <strong>custom sub-word tokenizer</strong>. This tokenizer splits an input sentence into a sequence of subword tokens instead of words, using an algorithm like <a href="https://huggingface.co/transformers/tokenizer_summary.html">byte-pair encoding or unigram language models</a> . Let’s get hold of the tokenizer that was used to pre-train our model,</p><div>

```python
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

```

</div><p>and apply it to some samples. The results are dictionaries where we’re mainly interested in the component <code>input_ids</code>:</p><table><thead><tr><th><strong><code>sample</code></strong></th><th><strong><code>tokenizer(sample)['input_ids']</code></strong></th></tr></thead><tbody><tr><td><code>'Das ist'</code></td><td><code>[3, 295, 127, 4]</code></td></tr><tr><td><code>'eine Frage' </code></td><td><code>[3, 155, 1685, 4]</code></td></tr><tr><td><code>'eine hochinteressante Frage' </code></td><td><code>[3, 155, 2426, 21477, 5004, 1685, 4]</code></td></tr></tbody></table><p>What do we see?</p><ol><li>The tokenizer marks the beginning and the end of a sample with a <code>3</code> and <code>4</code>, respectively.</li><li>Common words like <code>'Das'</code>, <code>'ist'</code>, <code>'eine'</code>, <code>'Frage'</code> are treated as single tokens.</li><li>Less frequent words like <code>'hochinteressante'</code> are split up into a sequence of sub-word token.</li></ol><p>So we need to</p><ul><li>apply the sub-word tokenizer to every word in our input samples, and</li><li>whenever it does split up a word, tag each sub-word like the entire word.</li></ul><p>This can be done as follows:</p><div>

```python
import numpy as np
import tqdm

def tokenize_sample(sample):
    seq = [
               (subtoken, tag)
               for token, tag in sample
               for subtoken in tokenizer(token)['input_ids'][1:-1]
           ]
    return [(3, 'O')] + seq + [(4, 'O')]

def preprocess(samples):
    tag_index = {tag: i for i, tag in enumerate(schema)}
    tokenized_samples = list(tqdm(map(tokenize_sample, samples)))
    max_len = max(map(len, tokenized_samples))
    X = np.zeros((len(samples), max_len), dtype=np.int32)
    y = np.zeros((len(samples), max_len), dtype=np.int32)
    for i, sentence in enumerate(tokenized_samples):
        for j, (subtoken_id, tag) in enumerate(sentence):
            X[i, j] = subtoken_id
            y[i,j] = tag_index[tag]
    return X, y

X_train, y_train = preprocess(train_samples)
X_val, y_val = preprocess(val_samples)

```

</div><h2>Step 3: Fine-tuning BERT on our custom NER task</h2><p>Training the model is now more or less the same as in the <a href="/wissens-hub/blog/take-control-of-named-entity-recognition-with-you-own-keras-model" target="_blank">preceding post</a>  with our bi-LSTM model:</p><div>

```python
import pandas as pd

NR_EPOCHS=10
BATCH_SIZE=16

optimizer = tf.keras.optimizers.Adam(lr=0.00001)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer=optimizer, loss=loss, metrics='accuracy')
history = model.fit(tf.constant(X_train), tf.constant(y_train),
                    validation_split=0.2, epochs=EPOCHS, 
                    batch_size=BATCH_SIZE)

```

</div><p>Well, except that now the model has some more parameters and training for just one epoch might take … some hours, depending on your hardware. Here’s the validation accuracy (note the lower bound):<img loading="lazy" width="606" height="322" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/L2y1suS5GogTeerx2bsA" alt="validation accuracy history" /></p><p>Note the domain of the accuracy and that the <em>x</em>-axis measures the training time in seconds.</p><h2>Step 4: Evaluation — gotcha again!</h2><p>Now that we have trained our custom-NER-BERT, we want to apply it and … face another problem: the <strong>model predicts tag annotations on the sub-word level</strong>, not on the word level. To obtain word-level annotations, we need to <strong>aggregate</strong> the sub-word level predictions for each word. Two obvious solutions come to mind:</p><ol><li>for each sub-word, choose the tag with highest probability, and then use a majority vote, or</li><li>average the predicted probabilities over all sub-words of a word, and then take the tag with highest average probability.</li></ol><p>Given predictions <code>pred</code> for a sequence <code>seq</code> of sub-words of shape <code>(len(seq), len(schema))</code>, this would amount to taking the tag indexed by</p><ol><li><code>scipy.stats.mode(np.argmax(pred, axis=-1))</code>, using the package <a href="https://www.scipy.org" target="_blank">SciPy</a> , or</li><li><code>np.argmax(np.mean(pred, axis=0))</code>,</li></ol><p>respectively, or, in the picture below, to go 1. first right, then down or 2. first down, then right:<img loading="lazy" width="1280" height="557" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/PMqLGifxSd2IkhvIXn2b" alt="sub-word prediction aggregation" /></p><p>We choose variant 2 and apply it to the model’s predictions as follows:</p><div>

```python
def aggregate(sample, predictions):
    results = []
    i = 1
    for token, y_true in sample:
        nr_subtoken = len(tokenizer(token)['input_ids']) - 2
        pred = predictions[i:i+nr_subtoken]
        i += nr_subtoken
        y_pred = schema[np.argmax(np.sum(pred, axis=0))]
        results.append((token, y_true, y_pred))
    return results

y_probs = model.predict(X_val)[0]
predictions = [aggregate(sample, predictions)
               for sample, predictions in zip(val_samples, y_probs)]

```

</div><p>Finally, we can evaluate the predictions on the level of tokens as a multi-class classification problem using <a href="https://scikit-learn.org" target="_blank">scikit-learn</a>  again as in the <a>preceding blog post</a> . Here is the scatterplot of the resulting f1-Scores versus the support for each tag class:<br /> <img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/mNSXE587RGKhVpATFusg" alt="NER-f1-score vs support per tag class" width="900" height="484" /></p><h2>Conclusion</h2><p>Let’s see how our new results compare to those of the previous post, and note that I’ve let BERT train <em>50 times as long</em> as the bi-LSTM:</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/G07fT3fTs6BVHjNJxXfF" alt="comparison NER-f1-scores per tag" width="900" height="435" /></p><p>We see that <strong>BERT significantly outperforms the bi-LSTM on difficult classes</strong> in our task. Is this only because of the more powerful network architecture and more training time? No! The scatterplot above shows a significant correlation between the f1-score and the supply of training data, and points us to the <strong>key advantage</strong> of the present approach:</p><ul><li>Before (bi-LSTM), we used it in the form of <strong>pre-trained word embeddings</strong>.</li><li>Now (BERT), we start from a <strong>fully trained language model</strong> that embodies much more knowledge.</li></ul><p>The upshot is:</p><blockquote><p><strong>The fewer data we have, the more important transfer learning becomes</strong>.</p></blockquote>

NER with little data? Transformers to the rescue!

<h1> Move n-gram extraction into your Keras model!</h1><p>In a project on large-scale text classification, a colleague of mine significantly raised the accuracy of our <a href="https://keras.io">Keras</a>  model by feeding it with bigrams and trigrams instead of single characters. For his experiments he could just modify the preprocessing and the model as he wished, but for production, it was much preferable to just replace the model <a href="https://www.tensorflow.org/tfx/guide/serving">being served by tensorflow</a>  and leave all other code unchanged. And that is what we did — move the bigram and trigram extraction into our neural network. In this blog post, I’ll show you the <a href="#idea">basic idea</a> , the <a href="#implementation">implementation</a> , an <a href="#experiment">application</a>  and the <a href="#limitations">limitations</a>  of our approach.</p><p><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iuef60ajSoqGrmW3YBxy" alt width="700" height="468" /></p><h2>The idea: n-gram extraction via convolution</h2><p>Suppose we want to process the quote</p><p><i>“I’d far rather be happy than right any day”</i></p><p>of <a href="https://en.wikipedia.org/wiki/Douglas_Adams">Douglas Adams</a> . Instead of looking at the text as a sequence of characters</p><p><span>I</span><span>‘</span><span>d</span><span> </span><span>f</span><span>a</span><span>r</span><span> </span><span>r</span><span>a</span><span>t</span><span>h</span><span>e</span><span>r</span> …</p><p>a neural network may profit from looking at pairs of adjacent characters, that is, at the sequence of bigrams</p><p><span>I’</span><span>‘d</span><span>d </span><span> f</span><span>fa</span><span>ar</span><span>r </span><span> r</span><span>ra</span><span>at</span><span>th</span><span>he</span><span>er</span> …</p><p>or even at the sequence of trigrams or n-grams for n larger 3. To feed the neural network, we need to convert characters into numbers, for example, using the ASCII or UTF-8 codes. Our bigrams then become sequences of pairs of numbers:</p><p><span>73, 39</span><span>39, 100</span><span>100, 32</span><span>32, 102</span><span>102, 97</span> …</p><p>If we encode these bigrams using the rule (a, b) ↦ N · a + b, where N is the size of our alphabet, we obtain a sequence of numbers again: in case N=256, this would be</p><p><span>73*256+39=18727</span><span>39*256+100=10084</span><span>100*256+32=25632</span><span>32*256+102=8294</span> …</p><p>More generally, we can encode n-grams for arbitrary n using the rule</p><p>(a<sub>0</sub>, …,a<sub>n-1</sub>) ↦ N<sup>n-1</sup> · a<sub>1</sub> + N<sup>n-2</sup> · a<sub>2</sub> + … + N · a<sub>n-2</sub> + a<sub>n-1</sub>.</p><p>Here comes the key observation: with this encoding rule,</p><blockquote><p><b>extracting n-grams becomes a convolution of the sequence of character codes with the kernel (1,N, …, N<sup>n-1</sup>).</b></p></blockquote><p>And this preprocessing step can easily be inserted as a first step into any character-level text-processing neural network.</p><h2>The implementation</h2><p>As a warm-up, let us implement the n-gram extraction as a convolution with <a href="https://www.numpy.org">NumPy</a> . Given a <a href="https://docs.scipy.org/doc/numpy/user/quickstart.html">NumPy array</a>  of character codes, the n-gram length n and the size of the alphabet N, the following function returns the sequence of encoded n-grams as an array:</p>

```src src-python
import numpy as np

def ngrams_numpy(array, n, alphabet_size):
    kernel = np.power(alphabet_size, range(0, n))
    return np.convolve(array, kernel, mode='valid')

```

<p>Next, how about the deep learning library <a href="https://keras.io/">Keras</a> ? Suppose we already have a working text-processing model whose input are (batches of) sequences of character codes. Then we can add bigram or n-gram extraction as a first layer using a <a href="https://keras.io/layers/core/">lambda layer</a>  in one line. Indeed, given a batch of samples in form of a tensor of shape (<code>batch_size</code>, <code>sample_length</code>), the following function returns a batch of encoded bigrams in form of a tensor of shape (<code>batch_size</code>, <code>sample_length - 1</code>):</p>

```src src-python
from keras.layers import Lambda

def bigrams_lambda_layer(alphabet_size):
    return Lambda(lambda x: x[:,:-1] + x[:,1:] * alphabet_size)

```

<p>However, lambda layers in Keras may cause <a href="https://github.com/keras-team/keras/issues/5298">problems</a>  <a href="https://github.com/keras-team/keras/issues/7184">when</a>  <a href="https://github.com/keras-team/keras/issues/11744">saving</a> , <a href="https://stackoverflow.com/questions/52845785/load-model-and-lamda-layer-in-keras">loading</a>  or <a href="https://forums.fast.ai/t/unable-to-save-model-checkpoints-when-using-lambda-in-model/827">checkpointing</a>  the model.</p><p>For further deployment of a model, for example with <a href="https://www.tensorflow.org/tfx/guide/serving">tensorflow serving</a> , it might be better to avoid a lambda layer and to use a <a href="https://keras.io/layers/convolutional/">1d-convolutional layer</a>  with fixed weights as follows:</p>

```src src-ipython
import numpy as np
from keras import layers, backend

def ngram_block(n, alphabet_size):
    def wrapped(inputs):
        layer = layers.Conv1D(1, n, use_bias=False, trainable=False)
        x = layers.Reshape((-1, 1))(inputs)
        x = layer(x)
        kernel = np.power(alphabet_size, range(0, n), 
                          dtype=backend.floatx())
        layer.set_weights([kernel.reshape(n, 1, 1)])
        return layers.Reshape((-1,))(x)

    return wrapped

```

<p>This function can be used like a layer:</p>

```src src-python
bigrams_tensor = ngram_block(2, alphabet_size)(input_tensor)

```

<p>See also the <a href="#org9402343">source code</a>  for the <a href="#experiment">experiment below</a> . What this function does is</p><ul><li><em>create a 1d-convolutional layer</em> <code>layer</code> with one feature map, window size <i>n</i>, zero bias vector and frozen weights that are not changed during training,</li><li><em>reshape the input</em> <code>inputs</code>, which is a tensor of shape (<code>batch_size</code>, <code>sample_length</code>), to a tensor <code>x</code> with shape (<code>batch_size</code>, <code>sample_length</code>, 1) (necessary because convolutional layers operate on sequences of vectors and not on sequences of scalars),</li><li><em>apply the convolutional layer </em>to the reshaped input,</li><li><em>set the kernel</em> of the convolutional layer and</li><li><em>reshape the output</em> of the convolutional layer from (<code>batch_size</code>, <code>sample_length</code>, 1) to (<code>batch_size</code>, <code>sample_length</code>) again.</li></ul><h2>An experiment</h2><p>Let us finally see how this idea works out for a classical test case, the <a href="http://qwone.com/~jason/20Newsgroups/">20 newsgroups dataset</a> , where the task is to guess the topic of a given post from its text. We shall use a simple character-level convolutional network and see how n-gram extraction inside the model affects the classification accuracy and and training time.</p><p>To load the data, we use the datasets module of <a href="https://scikit-learn.org">scikit-learn</a> :</p>

```src src-ipython
from sklearn.datasets import fetch_20newsgroups as fetch

data = fetch(subset="train", remove=("headers", "footers", "quotes"))
posts, topics = data["data"], data["target"]

```

<p>Now <code>posts</code> is a list of newsgroup posts as strings, and <code>topics</code> is a list of numbers representing the respective newsgroup topics. For each topic, we have 350 to 600 samples:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/GPy5EhKMRmyQAJTyl8m9"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/GPy5EhKMRmyQAJTyl8m9" alt /></a> </p><p>Note that this is <em>way too little data for a character-level model to perform well.</em> But let us try nevertheless.</p><p>We apply some minimal preprocessing and</p><ul><li>convert the characters to lower case,</li><li>filter out all characters that are not contained in our chosen <code>ALPHABET</code>,</li><li>replace the remaining characters by their index in the <code>ALPHABET</code>,</li><li>trim the sequence of indices to a fixed length <code>MAX_LEN</code>,</li><li>stack all those sequences in one large <a href="https://docs.scipy.org/doc/numpy/user/quickstart.html">NumPy array</a> :</li></ul>

```src src-ipython
import numpy as np

ALPHABET = "abcdefghijklmnopqrstuvwxyz1234567890 !$#()-=+:;,.?/"
MAX_LEN = 1000

def encode_sample(sample, index):
    indices = [index[char] for char in sample if char in index]     
    return np.resize(np.array(indices), MAX_LEN)

index = {char: i + 1 for i, char in enumerate(ALPHABET)}
X = np.stack([encode_sample(x.lower(), index) for x in posts])
y = np.eye(20)[topics]

```

<p>Now <code>X</code> is an array of shape (<code>len(posts)</code>, <code>MAX_LEN</code>), and <code>y</code> is an array of shape (<code>len(posts)</code>, 20) containing the one-hot encoded topics.</p><p>As a baseline, we train a simple convolutional model:</p>

```src src-ipython
from keras import layers, models, optimizers

LAYER_PARAMS = [[64, 3, 3], [128, 3, 3]]
EMBEDDING_DIM = 16

def build_model():
    inputs = layers.Input(shape=(MAX_LEN,))
    x = layers.Embedding(len(ALPHABET), EMBEDDING_DIM)(inputs)
    for filters, kernel_size, pool_size in LAYER_PARAMS:
        x = layers.Conv1D(filters, kernel_size, activation="relu")(x)
        x = layers.BatchNormalization()(x)
        x = layers.SpatialDropout1D(0.15)(x)
        x = layers.MaxPooling1D(pool_size)(x)
    x = layers.GlobalAveragePooling1D()(x)
    x = layers.Dense(20, activation="softmax")(x)
    model = models.Model(inputs=inputs, outputs=x)
    model.compile(optimizer=optimizers.Adadelta(),
                  loss="categorical_crossentropy", metrics=["acc"])
    return model

model = build_model()
history = model.fit(X, y, epochs=60, batch_size=20, 
                    validation_split=0.2)

```

<p>The results are quite poor — the validation accuracy reaches just 60 percent<a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iodN5RMFRdKqbCBADhPB"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iodN5RMFRdKqbCBADhPB" alt /></a> </p><p>By careful tuning of hyperparameters, things certainly could be improved a bit.</p><p>Now let us see how bigram and trigram extraction will affect performance of the model. Using the <a href="#org14d5f09">function <code>ngram_block</code>,</a>  we only need to insert the line <code>x = ngram_block(n, size)(inputs)</code> between the <code>Input</code> and <code>Embedding</code> layers in <code>build_model</code> as follows:</p>

```src src-ipython
def build_ngram_model(n):
    inputs = layers.Input(shape=(MAX_LEN,))
    x = ngram_block(n, len(ALPHABET))(inputs)
    x = layers.Embedding(pow(len(ALPHABET), n), n * EMBEDDING_DIM)(x)
    for filters, kernel_size, pool_size in LAYER_PARAMS:
        x = layers.Conv1D(filters, kernel_size, activation="relu")(x)
        x = layers.BatchNormalization()(x)
        x = layers.SpatialDropout1D(0.05 + 0.1 * n)(x)
        x = layers.MaxPooling1D(pool_size)(x)
    x = layers.GlobalAveragePooling1D()(x)
    x = layers.Dense(20, activation="softmax")(x)
    model = models.Model(inputs=inputs, outputs=x)
    model.compile(optimizer=optimizers.Adadelta(),
                  loss="categorical_crossentropy", metrics=["acc"])
    return model

```

<p>We also raised the embedding dimension (because now we want to embed bigrams and trigrams instead of single characters) and use an adaptive spatial dropout rate. Let us see how the n-gram model performs:</p>

```src src-ipython
for n in range(1, 4):
    build_ngram_model(n).fit(X, y, epochs=40, 
                             batch_size=20, validation_split=0.2)

```

<p>The training histories show that <strong>n-gram extraction yields a significant improvement</strong>:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/U92DkAFTSaecZEF4Ola5"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/U92DkAFTSaecZEF4Ola5" alt /></a> </p><p>Indeed, the mean validation accuracy of the last 5 training epochs increased by more than 10 percent:</p><table><colgroup><col></col><col></col><col></col><col></col></colgroup><thead><tr><th>n</th><th>1</th><th>2</th><th>3</th></tr></thead><tbody><tr><td><b>mean validation accuracy</b></td><td>0.5796</td><td>0.6401</td><td>0.7064</td></tr></tbody></table><h2>One limitation of the technique</h2><p>Why did we stop at trigrams in the experiment above? The reason is that we do not only encode the n-grams that occur in our samples, but reserve codings for all n-grams that could possibly occur. And that makes a <em>huge difference</em> when n is growing larger:</p><table><colgroup><col></col><col></col><col></col><col></col><col></col><col></col></colgroup><thead><tr><th>n</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th></tr></thead><tbody><tr><td><b>#(occuring n-grams)</b></td><td>52</td><td>2,596</td><td>47,203</td><td>214,362</td><td>551,904</td></tr><tr><td><b>#(potential n-grams)</b></td><td>51</td><td>2,601</td><td>132,651</td><td>6,765,201</td><td>345,025,251</td></tr></tbody></table><p>And therefore, <em>the embedding layer will need memory increasing exponentially with </em><i>n</i>. This is the reason why we stick to bigrams or trigrams. By the way, the numbers above where extracted as follows:</p>

```src src-ipython
import pandas as pd

def all_ngrams(n):
    length = MAX_LEN - n + 1
    def ngrams(x):
        return set(zip(*[x[i:length + i] for i in range(0, n)]))
    
    return set().union(*[ngrams(x) for x in X])

ns = range(1,6)
alphabet_size = len(ALPHABET)
cts = {'#(occuring n-grams)': [len(all_ngrams(n)) for n in ns], 
       '#(potential n-grams)': [pow(alphabet_size, n) for n in ns]}
pd.DataFrame(cts, index = pd.Index(ns, name='n')).transpose()
```

<p> </p>

Move n-gram extraction into your Keras model!

IT-Consultant / Machine Learning Engineer

<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://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/eKqfdMqNRRWu4rdHjss8" 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

Key Account Managerin

<p>Am 25. Oktober 2018 wurde im weltberühmten Auktionshaus Christie’s in New York das <a href="https://www.christies.com/features/A-collaboration-between-two-artists-one-human-one-a-machine-9332-1.aspx" target="_blank">Bild von Edmond de Belamy für 423.500$ verkauft</a> . Das Besondere an diesem Bild? Der Künstler hinter Edmonds Gemälde ist keine reale Person, sondern eine künstliche Intelligenz des Pariser Kollektivs Obvious; und das Bild ist entstanden aus einem sogenannten <strong>Generative Adversarial Network</strong>. Es ist das erste Mal, dass ein Werk aus dem maschinellen Lernen unter den Hammer eines so bedeutenden Auktionshauses gekommen ist.</p><p><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/3A2hzjf1R8udwP0fp1ND" alt="Edmond de Belamy, Copyright Christies/Obvious" /><br /> Gemälde „Edmond de Belamy“. Quelle/Copyright: <a href="http://obvious-art.com">Obvious</a> </p><p>Anlässlich dieses Ereignisses möchten wir an dieser Stelle einmal erklären, wie Edmond de Belamy und seine Familie entstanden sind. Dafür beschreiben wir zunächst die allgemeine Idee von generativen Netzwerken, bevor wir eine einfache Implementation mit Keras und Tensorflow vorstellen und schließlich noch einen Ausblick darauf geben, wofür diese Modelle verwendet werden können.</p><h2>Was ist ein Generatives Netzwerk?</h2><p>Bei dem Algorithmus, der von Obvious genutzt wurde, um die Bilder der Familie de Belamy zu erzeugen, handelt es sich wie bereits erwähnt um ein Generative Adversarial Network (GAN, zu deutsch etwa <em>Erzeugendes Gegnerisches Netzwerk</em>). GAN ist eine besondere Architektur von <strong>Neuronalen Netzen</strong>, in der zwei Netzwerke im Gegenspiel zueinander agieren und so voneinander lernen. GANs wurden erstmals 2014 von <a href="https://arxiv.org/abs/1406.2661">Ian Goodfellow und seinen Kollegen</a>  vorgestellt und erleben seitdem große Beliebtheit in der Forschungsgemeinschaft.</p><p>Um das Prinzip von Generativen Modellen zu erklären, wollen wir uns zunächst einer Analogie bedienen. In unserer Geschichte gibt es drei Akteure:</p><ul><li> Gabi ist Kunstfälscherin. Ihr größtes Ziel ist es, eines ihrer gefälschten Gemälde im Auktionshaus Miller’s versteigern zu lassen.</li><li> Diana ist Praktikantin bei Miller’s. Ihr Job ist es, gefälschte Gemälde auszusortieren.</li><li> Olivia ist die Chefeinkäuferin bei Miller’s. Sie ist unfehlbar und weiß genau, welche Bilder authentisch sind und welche nicht. Olivia steht aber kurz vor der Pension und möchte Diana daher anlernen.</li></ul><p>Gabi und Diana sind zu Beginn unserer Geschichte noch sehr unerfahren, doch entwickeln sie ihre jeweiligen Fähigkeiten im Laufe der Zeit immer weiter. Dabei läuft der Lernprozess in Zyklen ab. Zu Beginn eines jeden Zyklus fertigt Gabi einige Kunstfälschungen an und reicht diese bei Miller’s ein. Dort gelangen sie, zusammen mit echten Gemälden, zu Diana, die erkennen soll, welche Bilder echt sind und welche nicht. Diana schreibt ihre Einschätzung zu jedem Bild auf und schickt sie an Gabi und Olivia. Olivia kann mit ihrer Erfahrung Dianas Einschätzungen berichtigen, wodurch sie Schlussfolgerungen ziehen kann und in Zukunft Fälschungen besser erkennt. Gabi wiederum sieht, wie ihre Fälschungen beim Auktionshaus angekommen sind und versucht, davon ausgehend bessere Fälschungen zu malen. Damit beginnt der nächste Zyklus.</p><p>Anhand dieser kurzen Veranschaulichung wird die Idee von GANs deutlich. Es existieren zwei Neuronale Netze, die gegeneinander spielen und aus den Resultaten des jeweils anderen Netzes lernen. Das erste Netz, der <strong>Generator</strong>, erhält als Eingabe ein zufälliges Signal und erzeugt daraus ein Bild. Dieses bildet gemeinsam mit Instanzen des Trainingsdatensatzes, also echten Bildern, den Input des zweiten Netzes, dem <strong>Diskriminator</strong>. Die Aufgabe des Diskriminators ist, zu entscheiden, welche Bilder aus dem Trainingsdatensatz und welche vom Generator stammen. Der Diskriminator lernt aus seinen Vermutungen, da ihm anschließend ein Orakel den Ground Truth, also die wahre Herkunft der Bilder, vermittelt. Wie der Lernprozess in den Netzen selbst stattfindet, wurde zum Beispiel <a href="/wissens-hub/blog/wie-trainiert-man-eigentlich-neuronale-netze">hier erklärt</a> .</p><h2>Was bedeutet die Signatur in Edmonds Portrait?</h2><p>Das Portrait von Edmond de Belamy trägt, wie es bei Gemälden üblich ist, die Signatur des Künstlers. Doch wie soll ein Algorithmus signieren? Obvious entschied sich für Folgendes:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/xSrkdRtTzub4gcSZ0q8L"><img loading="lazy" width="250" height="43" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/xSrkdRtTzub4gcSZ0q8L" alt="Signature on Edmond de Belamy | Source: Christies, Obvious" /></a> <br /> Signatur von „Edmond de Belamy“. Quelle/Copyright: <a href="http://obvious-art.com">Obvious</a> </p><p>Diese Formel beschreibt ein GAN aus mathematischer und spieltheoretischer Sicht. Hier handelt es sich um ein typisches Minimax-Spiel, bei dem zwei Gegenspieler die jeweils optimale Strategie verfolgen und so letzten Endes im Nash-Gleichgewicht landen. Wenn wir uns die Gleichung näher ansehen, erkennen wir unsere Akteure wieder: Den Diskriminator D und Generator G. Der Diskriminator versucht, seine eigene Leistung zu maximieren, ausgedrückt durch die Kreuzentropie <code>E(log(D(x))</code>. Der Generator auf der anderen Seite verfolgt aber eine Minimierungsstrategie: Er möchte die Leistung des Diskriminators auf seinen eigenen Bildern minimieren (erneut ausgedrückt durch die Kreuzentropie <code>E(1 - log(D(G(z))))</code>).</p><h2>Ein einfaches GAN mit Keras und Tensorflow</h2><p>Im Folgenden möchten wir zeigen, wie man mit Keras und Tensorflow selbst ein einfaches Generatives Modell implementieren kann, das handschriftliche Ziffern lernt und nachbildet. Die Implementation orientiert sich dabei an der ursprünglichen Version von Ian Goodfellow, und berücksichtigt nicht die zahlreichen Verbesserungsstrategien, die seitdem erschienen sind. Der Code ist vollständig auch als <a href="https://github.com/tsabsch/Simple_GAN">IPython (Jupyter) Notebook</a>  verfügbar.</p><p>Im ersten Schritt laden wir unseren Datensatz in unser Notebook. Wir verwenden hierfür den MNIST-Datensatz, der sehr häufig als Demonstration für GANs verwendet wird. Wir berechnen die Auflösung der Bilder und normalisieren sie, sodass sie im Intervall [0, 1] liegen. Dadurch verbessert sich die Stabilität des Lernprozesses.</p><p></p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/jw8PmgepTqqH5E7Iucpj"><img loading="lazy" width="250" height="49" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/jw8PmgepTqqH5E7Iucpj" alt /></a> <br /> Drei Beispielbilder aus dem MNIST-Datensatz.</p><p>Als nächstes definieren wir unseren Diskriminator. Er erhält als Eingabe ein Bild, das wir über drei verdeckte Schichten verkleinern. Als Aktivierungsfunktion zwischen den Schichten verwenden wir die Leaky Rectified Linear Units, die uns eine schwache Aktivierung für negative Werte und eine lineare Aktivierung für positive Werte liefert. Die Ausgabeschicht enthält nur einen einzelnen Knoten, der die Information darüber enthalten wird, ob das Bild aus dem Trainingsdatensatz stammt oder vom Generator.</p><p></p><p>Wir definieren nun unseren Generator. Er bekommt als Input ein zufälliges Rauschsignal. Über drei verdeckte Schichten erhöhen wir die Auflösung des Signals, bis wir in der letzten Schicht die gewünschte Auflösung der MNIST-Bilder erhalten.</p><p></p><p>Für unseren Trainingsprozess ist es sinnvoll, jeweils nur ein Netz gleichzeitig zu trainieren. Daher werden wir in jeder Epoche zuerst den Diskriminator und dann den Generator trainieren. Für den Generator kompilieren wir uns hierfür ein kombiniertes Modell, in dem der Diskriminator nicht trainierbar ist. Als Optimierer verwenden wir Adam, eine Variante des stochastischen Gradientenabstiegsverfahrens, und die binäre Kreuzentropie als Fehlerfunktion.</p><p></p><p>Wir trainieren in Minibatches, also immer mit einer Untermenge des Trainingsdatensatz. Die Hälfte unserer Batches besteht aus echten Bildern, die andere Hälfte aus generierten Bildern.</p><p></p><p>Hier sind einige Bilder, die unser so trainierter Generator erzeugt hat:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/6ZQK1LrR34cXrm6USwtA"><img loading="lazy" width="250" height="181" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/6ZQK1LrR34cXrm6USwtA" alt /></a> </p><p>Auch wenn einige Bilder noch nicht ganz überzeugen mögen, kann man mit dieser einfachen Implementierung das Potential von Generativen Modellen erkennen.</p><h2>Wie kann ich mein Modell verbessern?</h2><p>Mit dieser Frage beschäftigen sich zahlreiche Forschungsgruppen. Seit der ursprünglichen Publikation von Ian Goodfellow sind über 5000 Arbeiten veröffentlicht worden, die Ansätze für bessere Ergebnisse von GANs vorschlagen, oder neue Anwendungen erproben. Eine populäre Verbesserung ist etwa die Verwendung von <strong>Batch Normalization</strong>, da sich oftmals der Generator in einem lokalen Minimum festgesetzt und nur noch ähnliche Bilder erzeugt hat. Mit dem gleichen Ziel wurde auch die <strong>Minibatch Discrimination</strong> eingeführt, bei der der Diskriminator mehrere Bilder gleichzeitig präsentiert bekommt.</p><p>In einem anderen Ansatz wird vorgeschlagen, den Generator und Diskriminator mit einer geringen Bildauflösung zu initialisieren und im Laufe des Trainings <a href="https://research.nvidia.com/publication/2017-10_Progressive-Growing-of" target="_blank">schrittweise zu erhöhen</a> . Zuletzt hat auch die <a href="https://arxiv.org/abs/1809.11096">Erhöhung der Netzwerkparameter und Größe der Minibatches</a>  für sehr gute Ergebnisse gesorgt.</p><h2>Was sind mögliche Anwendungen von GANs?</h2><p>Auf den ersten Blick scheint es sich bei GANs nur um eine (intelligente) Spielerei zu handeln, um mehr oder weniger realitätsnahe Bilder zu erzeugen. Doch GANs können auch ganz praktische Anwendungen haben. Hier seien drei Beispiele aufgeführt:</p><p>In vielen Krimiserien nehmen die Ermittler das verrauschte Bild einer Überwachungskamera und erhöhen auf scheinbar magische Weise dessen Auflösung, wodurch sie wichtige Infos, wie etwa das Autokennzeichen erkennen können. Was bislang Fiktion war, könnte bald tatsächlich eingesetzt werden, denn Christian Ledig und Kollegen stellten SRGAN vor, was die <a href="https://arxiv.org/abs/1609.04802">Auflösung von Bildern deutlich erhöhen kann</a> .</p><p><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/L1wo0h00SXG9i3NsLjD5" alt="Superresolution durch SRGAN, Copyright Christies/Obvious" /><br /> Quelle: <a href="https://github.com/tensorlayer/srgan">Tensorlayer / SRGAN</a> </p><p>Unzählige (Video-)Kameraaufnahmen des frühen 20. Jahrhunderts existieren nur in Schwarz-Weißer-Farbe. Die nachträgliche Einfärbung erfolgt nur selten, da sie manuell durchgeführt werden muss, was aufwändig und teuer ist. Das GAN von Kamyar Nazeri und Kollegen lernt, <a href="https://arxiv.org/pdf/1803.05400.pdf">Graustufen-Bilder einzufärben</a> .</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iPWjehNXRGWmyEjE6v77"><img loading="lazy" width="250" height="75" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iPWjehNXRGWmyEjE6v77" alt="Image Colorization with GANs | Source: ImageLab" /></a> <br /> V.l.n.r.: Graustufe, Original, SRGAN. Quelle: <a href="https://github.com/ImagingLab/Colorizing-with-GANs">ImagingLab</a> </p><p>Auch die Modeindustrie könnte vom Einsatz Generativer Netzwerke profitieren. So gibt es bereits erfolgreiche Versuche, <a href="https://www.ijcai.org/proceedings/2017/0520.pdf">neue Kleidungsstile zu entwickeln</a>  oder <a href="http://on-demand.gputechconf.com/gtc/2018/presentation/s8776-gan-fashion-photo-shoot-garment-to-model-images-using-conditional-gans.pdf">Models neu einzukleiden</a> , um so teuren Fotoshootings zu entgehen.</p><h2>Fazit</h2><p>In diesem Artikel haben wir uns mit der grundlegenden Idee von Generative Adversarial Networks beschäftigt. Diese stellen eine besondere Form von Neuronalen Netzen dar, bei denen zwei Teilnetze durch ein Minimax-Spiel versuchen, sich gegenseitig auszutricksen. Dadurch erlangt eines der beiden Netze die Fähigkeit, neuartige Bilder zu erzeugen. Der Einstieg in GANs ist nicht kompliziert, wie wir mit unserer simplen Implementierung selbst erfahren konnten. Auch wenn das volle Potential der Netzwerke noch nicht ausgereizt zu sein scheint, zeigt sich schon jetzt eine hohe Relevanz für verschiedenste Anwendungsfelder.</p><p>Wenn Sie mehr über künstliche Intelligenz erfahren möchten, finden Sie weitere Informationen auf <a href="http://codecentric.ai">unserer Webseite</a> .</p>

Eine kurze Einführung in Generative Adversarial Networks

<p>Die Generierung künstlicher Bilder mittels Deep Learning schlägt seit einigen Jahren immer wieder hohe Wellen in den Medien. Im Rahmen von <a href="https://www.codecentric.de/kuenstliche-intelligenz/">codecentric.ai</a>  beschäftigen auch wir uns seit Kurzem mit diesem Thema. In diesem Blogartikel zeigen wir euch, wie wir uns mithilfe von Generative Adversarial Networks eigene, neue Emojis erstellen.</p><h2>Neue Bilder mit Deep Learning generieren</h2><p>Der Nutzen künstlicher neuronaler Netze zur Klassifikation von Daten, wie etwa Krankheiten, <a href="/wissens-hub/blog/machine-deep-learning-diesel-object-detection">Autos</a>  oder Weinsorten, ist schon seit Jahrzehnten bekannt. Der Einsatz von Netzen zur Generierung von Daten hingegen ist ein recht neuer Forschungszweig im Bereich Deep Learning. Hier liegen aktuell insbesondere die sogenannten Generative Adversarial Networks im Fokus.</p><p>Bei einem Generative Adversarial Network (GAN) handelt es sich um eine besondere Architektur von neuronalen Netzen, in der zwei Netzwerke miteinander interagieren und so voneinander lernen. Das erste Netzwerk – der Generator – erzeugt neue Inhalte, meist Bilder. Das zweite Netzwerk – der Diskriminator – hingegen versucht zu erkennen, ob ein Inhalt vom Generator stammt oder von einem separaten Trainingsdatensatz. Nach erfolgreichen Training kann dann der Generator verwendet werden, um neue, glaubwürdige Inhalte zu erzeugen. GANs wurden erstmals 2014 vorgestellt und werden seit kurzer Zeit auch im Unternehmenskontext verprobt. Eine generelle Einführung in das Thema findet ihr in <a href="/wissens-hub/blog/eine-kurze-einfuehrung-in-generative-adversarial-networks">unserem Blogartikel</a> :</p><p>Seit der ursprünglichen Architektur wurden zahlreiche Varianten und Modifikationen entwickelt. So wird in Wasserstein-GAN der Wasserstein-Loss als Fehlerfunktion eingeführt, was zu einem intuitiveren Fehlergradienten führt und dadurch die Konvergenzrate erhöht.</p><h3>Progressive Growing of GANS</h3><p>Ein wichtiger Meilenstein in der letzten Zeit war die Beschreibung und Umsetzung von Progressive GANs (PGANs) durch NVIDIA Research, die im Paper <a href="https://research.nvidia.com/publication/2017-10_Progressive-Growing-of" target="_blank">Progressive Growing of GANs for Improved Quality, Stability, and Variation</a>  (Tero Karras, Timo Aila, Samuli Laine (alle NVIDIA) und Jaakko Lehtinen (NVIDIA und Aalto University)) veröffentlicht wurden. PGANs führen eine fundamentale Neuerung beim Trainieren der beteiligten neuronalen Netze ein: Das Training startet bei groben Auflösungen und wird dann schrittweise feiner. Zuerst werden also nur wenig pixel-große Repräsentationen der Bilder antrainiert und diskriminiert. Die Auflösung wird dann im Laufe des Trainingsprozesses schrittweise gesteigert. Dies führt dazu, dass der Trainingsprozess stabiler ist und schneller konvergiert.</p><p>Ein Showcase für PGANs ist die Generierung künstlicher ‘Promis’. Die Ergebnisse sind fotorealistisch und von echten Hollywood-Stars im Stil kaum zu unterscheiden.</p><div><div><div> <img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/vEMzI0FT3GyY9ElBbWCF" alt="YouTube" /><div><p>Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.<br /><a href="https://policies.google.com/privacy" target="_blank">Mehr erfahren</a> <br /></p><p><a href="#">Video laden</a> </p><p> <small>YouTube immer entsperren</small></p></div></div></div><div></div></div><p>Angespornt von der herausragenden Qualität dieser Ergebnisse haben wir versucht, uns mit PGAN neue Mitarbeiter zu generieren. Leider ist unser Datensatz mit etwa 500 Bildern sehr klein. Der CelebA-Datensatz, den NVIDIA für das obige Video verwendet, enthält 200.000 Bilder. Unsere neuen Kollegen sehen uns daher noch ziemlich ähnlich:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/0i8XKlIcRaWGOip6SYLG"><img loading="lazy" width="250" height="250" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/0i8XKlIcRaWGOip6SYLG" alt /></a> <br /> Unsere Kollegen Jonas und Olga, sowie ihre nächsten Nachbarn unter den generierten Mitarbeitern. Overfitting ist klar erkennbar.</p><h2>Generierung von neuen Emojis</h2><p>An dieser Stelle möchten wir euch zeigen, wie wir PGAN so trainieren können, dass es neuartige Emojis generiert. Emojis eignen sich für unser Experiment einigermaßen gut, da sie eine geringe Auflösung haben. Die geringe Auflösung ist für uns wichtig, da wir die Kosten für das Experiment erst einmal gering halten möchten. Außerdem erhoffen wir uns interessante und amüsante Ergebnisse.</p><p>Als Trainingsset verwenden wir die Emojis von <a href="http://www.joypixels.com" target="_blank">EmojiOne</a>  in der 32×32-Auflösung, nachdem uns Apple eine Absage für die Nutzung ihrer Emojis für diesen Blogartikel untersagt hat. Der Datensatz enthält 893 Emojis, was für ein Trainingsset relativ klein ist.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/VZ1zf0FnQbCFisQ846Mg"><img loading="lazy" width="250" height="83" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/VZ1zf0FnQbCFisQ846Mg" alt /></a> <br /> Auszug aus dem verwendeten Datensatz</p><h3>Setup und Trainingsprozess</h3><p>Für die Generierung der neuen Emojis nutzen wir die originale PGAN-Implementierung von NVIDIA, die auf GitHub verfügbar ist. NVIDIA Research hat alle wichtigen Informationen rund um das Paper auf einer eigenen Seite zum Nachlesen zusammengefasst.</p><p>Das Training führen wir auf einer <a href="https://aws.amazon.com/de/ec2/instance-types/p3/" target="_blank">p3.2xlarge</a>  Amazon-EC2-Cloudinstanz durch. Diese Instanz besitzt eine Tesla V100 GPU mit 16GB Speicher (Kosten aktuell bei ca 7.000€). Ein Trainingsdurchlauf hat ca. acht Stunden gedauert und uns somit 31$ gekostet (3,82$/h). Insgesamt haben wir zwei Durchläufe gebraucht, um unsere letztendlichen Ergebnisse zu erzielen.</p><p>Bevor wir das Training starten können, müssen wir zunächst unsere Emojis in das geeignete Format bringen. PGAN speichert die verwendeten Trainingsbilder in tfrecords-Dateien. Um eigene Datensätze verwenden zu können, bringt PGAN die Funktion <code>create_from_images</code> mit, welche wir mittels</p><p><code>python dataset_tools.py create_from_images </code></p><p>ausführen können. Da die Bilder nativ im Farbraum <code>P</code> vorliegen, konvertieren wir sie vorher in den <code>RGB</code>-Farbraum.</p><p>Als nächstes registrieren wir unseren neuen Datensatz in der config.py, indem wir die Zeile</p><p><code>desc += '-emojis'; dataset = EasyDict(tfrecord_dir='emojis'); train.mirror_augment = True</code></p><p>hinzufügen, und die übrigen Datensätze auskommentieren. In der config.py können wir auch weitere Einstellungen vornehmen, wie etwa die Anzahl an GPUs. Da wir auf einer p3.2xlarge trainieren, wählen wir hier die Einstellung <code>-preset-v2-1gpu</code>.</p><p>Jetzt können wir das Training starten, indem wir einfach <code>python train.py</code> ausführen. Aufgrund der signifikanten Kosten stoppen wir den Trainingsprozess, sobald wir eine Konvergenz auf den Ergebnissen sehen.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/bMxLUEyoQpOXrUJIv1AC"><img loading="lazy" width="250" height="100" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/bMxLUEyoQpOXrUJIv1AC" alt /></a> <br /> Zwischenergebnisse. Auflösung 4×4<br /> <a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/KMMc4JmHQteQSBkc8Pnu"><img loading="lazy" width="250" height="103" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/KMMc4JmHQteQSBkc8Pnu" alt /></a> <br /> Zwischenergebnisse. Auflösung 8×8<br /> <a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UFwGysyfTUaWN2F5BEsr"><img loading="lazy" width="250" height="100" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/UFwGysyfTUaWN2F5BEsr" alt /></a> <br /> Zwischenergebnisse. Auflösung 16×16<br /> <a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/mnZZT9OtT7uPUagdQqwh"><img loading="lazy" width="250" height="99" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/mnZZT9OtT7uPUagdQqwh" alt /></a> <br /> Finale Ergebnisse. Auflösung 32×32</p><p>Hier ein paar ausgewählte GANmojis:</p><table><tbody><tr><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/bbykqiwTAyZMAT530qCQ"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/bbykqiwTAyZMAT530qCQ" alt width="100" height="100" /></a> <p>creepy hat</p></td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/VvMgtXQbSVzMhgYdsq3A"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/VvMgtXQbSVzMhgYdsq3A" alt width="100" height="100" /></a> <p>Alter Schnuller</p></td><td><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Lj1qUURJTNS2dByJb24B" alt width="98" height="102" /><p>Evilmoji</p></td></tr><tr><td><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/o59VL14CTfiuGKLBGvcV" alt width="100" height="100" /><p>König der Baustelle</p></td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/MILEz49iSkyO1cu6hsgE"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/MILEz49iSkyO1cu6hsgE" alt width="100" height="100" /></a> <p>Rauchermoji</p></td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/8ZvCtfhZTLmhxWtrbVVQ"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/8ZvCtfhZTLmhxWtrbVVQ" alt width="99" height="96" /></a> <p>Zu viel Kaffee</p></td></tr><tr><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/raUCY85VQe6YIswRkkzT"><img loading="lazy" width="116" height="112" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/raUCY85VQe6YIswRkkzT" alt /></a> <p>Monobrow</p></td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/pRwVXMjfRxG21jWFo5jN"><img loading="lazy" width="118" height="114" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/pRwVXMjfRxG21jWFo5jN" alt /><br /> </a> Slomo Face Hit</td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/KU2MFFAnQ6OOFS33cdM1"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/KU2MFFAnQ6OOFS33cdM1" alt width="100" height="100" /></a> <p>Rorschach</p></td></tr><tr><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/fmnOCVofRNCdxMWHjuY8"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/fmnOCVofRNCdxMWHjuY8" alt width="100" height="100" /></a> <p>Shampoomoji</p></td><td><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/NIyExjhdSHeODV0YyYIG" alt width="100" height="100" /><p>Pizzamampf</p></td><td><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iYxgxdDZRQewA9GxArqI"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/iYxgxdDZRQewA9GxArqI" alt width="99" height="99" /></a> <p>Behind Windows</p></td></tr></tbody></table><p> </p><h3>Lessons Learned</h3><p>Bei der Generierung hatten wir einige Herausforderungen und Fehler, die uns nicht direkt aufgefallen und somit recht teuer geworden sind. Ein Beispiel ist der oben kurz erwähnte falsche Farbraum, der von Tensorflow nicht richtig erkannt wurde und deshalb unsere Emojis nur in Schwarz-Weiß erkannt hat. Dieser Fehler ist uns leider erst nach Abschluss des Trainings aufgefallen:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/5nHKfdWS96vpxV2F8cyD"><img loading="lazy" width="250" height="102" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/5nHKfdWS96vpxV2F8cyD" alt /></a> </p><p>Lesson Learned: Den Import der Trainingsdaten unmittelbar checken, entweder direkt in den tfrecord-Dateien oder zu Beginn des Trainings in der <code>reals.png</code>.</p><h2>Zusammenfassung und Fazit</h2><p>Mit genügend Trainingsdaten ist es inzwischen möglich, künstliche Inhalte von neuronalen Netzen generieren zu lassen. Die Qualität hängt dabei sowohl stark vom Trainingsset (beispielsweise der Größe oder Varianz) als auch von den eingesetzten Ressourcen ab. Wir haben mit einem recht überschaubaren Set an Trainingsdaten ohne spezielle Optimierungen bereits interessante Ergebnisse erzielt. Die Ergebnisse sind den ursprünglichen Emojis teilweise noch sehr ähnlich, was durch den kleinen Datensatz zu erwarten war. Eine gutes Trainingsset wäre idealerweise erheblich größer.</p><p>Die Generierung neuer Inhalte könnte auch heute schon für Unternehmen interessant sein. Perspektivisch könnten sogar gänzlich neue Geschäftsmodelle auf GANs basieren, z. B. die Erstellung reiner GAN-Stockphoto-Archive, die entweder vermarktet oder besser noch unter Creative-Commons-Lizenz bereitgestellt werden. In Betracht ziehen muss man dabei jedoch die Kosten: Sowohl bei der Nutzung von Cloud-Instanzen als auch bei der Anschaffung eigener Hardware fallen nicht unerhebliche Gebühren an. Eigene Hardware ist zudem während des Trainings für recht lange Zeiten blockiert.</p><p>Abschließend möchten wir uns bei NVIDIA bedanken, die uns die Verwendung der Referenzimplementierung als Ausgangspunkt unserer Experimente erlaubt haben.</p>

GANmojis: Deep Learning meets Emojis

People Lead & Machine Learning Engineer

Die Bingo Bongo-Methode: ein spielerischer Software-Testing-Ansatz

<div><h2>Die EnterJS vorgestellt</h2><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LGWA1QDFScywYOrCoh59"><img width="250" height="188" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/LGWA1QDFScywYOrCoh59" alt="EnterJS" /></a> </p><p>Vom 20.06. – 21.06.2018 fand die JavaScript-Fachkonferenz <a href="https://www.enterjs.de" target="_blank">EnterJS</a>  zum fünften Mal statt. Die Konferenz wird organisiert und durchgeführt von heise Developer, dem Magazin iX und dem dpunkt.verlag. Der Schwerpunkt der Konferenz ist das JavaScript-Ökosystem mit all seinen Facetten. In über 45 Vorträgen standen neben der Entwicklung mit SPA-(Single-Page-Application-)Frameworks wie Vue.js, Angular oder React auch Progressive Web Apps, Dev-Ops-Themen, UI/UX-Design und Web Security im Fokus. Das Unit-Testing in JavaScript war ebenfalls ein Thema. Dieses stellte unser Kollege Holger Grosse-Plankermann mithilfe von <a href="/wissens-hub/blog/javascript-unit-tests-sind-schwer-aufzusetzen-keep-calm-use-jest" target="_blank">Jest</a>  vor. In diesem Blogbeitrag wollen wir die zentralen Themen der Konferenz vorstellen, die die aktuellen Entwicklungen des JavaScript-Universums widerspiegeln.</p></div><div><h2>Seven Things to do …</h2><p>Den ersten Talk der Konferenz hielt Chris Heilmann von Microsoft. Er sprach über verschiedene Aspekte der Entwicklung mit JavaScript, die sowohl Entwickler als auch Nutzer zufriedener machen. Chris nannte sieben Punkte, die – sollten wir sie befolgen – unser Leben als Entwickler erleichtern:<br /> </p><ol><li>Understanding that JavaScript is not a language</li><li>Concentrating on the now</li><li>Limiting our development environment</li><li>Making it harder to write bad code</li><li>Getting to know our tooling</li><li>Giving back to others</li><li>Muffling the noise</li></ol><p>Die ausführlichen Erläuterungen zu den Punkten findet ihr <a href="https://noti.st/codepo8/x9kOaw/seven-ways-to-be-a-happier-javascript-developer#sBYP22c" target="_blank">hier</a> . Einen Punkt möchten wir jedoch herausgreifen, der nicht nur die Entwicklung mit JavaScript betrifft, sondern allgemein auf die Entwicklung übertragen werden kann:</p><blockquote><p>In der Welt der unzähligen Möglichkeiten kann niemand ein Experte für alles sein.</p></blockquote></div><div><h2>Schwerpunkte der Konferenz</h2><h3>Modularisierung von Webanwendungen</h3><p>Aufgrund der Tatsache, dass heutige SPAs in vielen Belangen immer komplexer werden, wächst auch hier der Wunsch, SPAs zu modularisieren. Durch die Modularisierung erhofft man sich vergleichbare Vorteile, wie wir sie bereits aus Microservices-Architekturen aus dem Backend kennen. Allerdings ist zu beachten, dass die Kombination der unabhängigen Module für den Anwender wie eine einheitliche Anwendung aussehen soll. Für die Umsetzung solcher Modularisierung gibt es bereits unterschiedliche Möglichkeiten:<br /> </p><ul><li> Hyperlinks</li><li> iFrames</li><li> Majestic Modular Monoliths</li><li> Web Components</li></ul><p>Die wohl einfachsten Möglichkeiten sind beispielsweise die Verwendung von Hyperlinks zwischen verschiedenen Komponenten oder von iFrames in bestehenden Komponenten. Der Nachteil bei Hyperlinks ist, dass der vorherige Zustand beim Seitenwechsel verloren geht. Gegen iFrames spricht die erschwerte Kommunikation zwischen Komponenten sowie die dynamische Anpassung an Inhalte und die eingeschränkte Suchmaschinenoptimierung.<br /> Eine Alternative sind Majestic Modular Monoliths. Dabei werden einzelne Module erstellt und im Deployment zu einem Monolithen zusammengeführt. Innerhalb der Anwendung können die Module durch Lazy Loading nachgeladen werden (Beispiel: <a href="https://reactjs.org/docs/code-splitting.html" target="_blank">dynamic import in React</a> ).<br /> Im Gegensatz zu modularen Monolithen können <a href="https://www.webcomponents.org" target="_blank">Web Components</a>  durch unterschiedliche Frameworks in verschiedenen Versionen realisiert werden. Web Components ermöglichen es unter anderem, eigene HTML-Elemente zu realisieren, die durch eine JavaScript-Instanz kontrolliert werden. Erste Realisierungsmöglichkeiten von Web Components bieten <a href="https://angular.io/guide/elements" target="_blank">Angular Elements</a> , <a href="https://github.com/vuejs/vue-web-component-wrapper" target="_blank">Wrapper Components von Vue.js</a> , <a href="https://www.polymer-project.org" target="_blank"> Polymer </a>  oder auch <a href="https://reactjs.org/docs/web-components.html" target="_blank"> ReactJs </a> .<br /> Insgesamt bieten diese Möglichkeiten unterschiedliche Vor- und Nachteile und müssen je nach Anwendungsfall abgewägt werden.</p><h3>“Battle of the Frameworks”</h3><p>Battle (Bashing) of the Frameworks – in den letzten Jahren ein beliebtes Thema innerhalb der Community – fand auf der Konferenz beinahe nicht statt. Man hat gesehen, dass sich mittlerweile drei Frameworks (Angular, React & Vue.js) als enterprisefähig etabliert haben. Sie verfügen über ein ausgereiftes Ökosystem und werden von einer aktiven Community vorangetrieben. Die Wahl hängt somit eher von den persönlichen Vorlieben des Teams und nicht von dem mangelhaften Ökosystem des Frameworks ab. Allgemein war deutlich zu erkennen, dass sich alle Frameworks schnell weiterentwickeln und verschiedene Lösungsansätze zu unterschiedlichen Problemen bieten.</p><h3>Reaktive Anwendungen (RX)</h3><p>“Reactive is everywhere” und durfte auch nicht auf der EnterJS fehlen. <a href="http://reactivex.io" target="_blank"> ReactiveX </a> ist eine API für asynchrone Programmierung mittels Observables. <a href="https://rxjs-dev.firebaseapp.com" target="_blank"> RxJs </a>  ist die JavaScript-Implementierung der API. Das Angular-Framework baut z. B. grundlegend auf RxJS auf. Außerhalb des Frameworks wurde das Thema von Michael Hladky abgedeckt. Zum einen sprach er über das Scheduling mit RxJS, zum anderen zeigte er in einer unterhaltsamen Demo das Echtzeit-Stream-Processing von <a href="https://github.com/BioPhoton/angular-morse-code-example" target="_blank">Morsecode</a>  mit RxJS.</p><h3>Progressive Web Apps & Webassembly</h3><p>Progressive Web Apps (PWA) bieten dem JavaScript-Universum neue Möglichkeiten. Einmal geladen, bieten PWAs auch Offline-Funktionalität. Dabei lädt der Service Worker die benötigten Inhalte entweder aus dem Web oder aus dem Cache. Dies ermöglicht es der Businesslogik, vollständig im Client zu laufen. Hier kann in Zukunft auch <a href="https://webassembly.org" target="_blank"> WebAssembly </a>  (Wasm) ins Spiel kommen. Dies ist ein Standard für Bytecode, der unter anderem C- oder C#-Code mit nahezu nativer Performance dem Web zugänglich macht. So kann bestehende Businesslogik oder komplexe Logik, wie etwa bei Spielen und 3D-Anwendungen, auch ins Web portiert werden. Dabei darf Wasm nicht als Alternative zu JavaScript gesehen werden, sondern lediglich als Erweiterung des bestehenden Toolkits. Insgesamt stellen PWAs somit eine Konkurrenz zu nativen, mobilen Apps dar. Aber nicht nur das mobile Development ist für PWAs ein Anwendungsgebiet, sondern auch Anwendungen mit sensiblen Daten – gerade in Zeiten der DSGVO – bieten sich für diese Art der Web App an.</p><h3>Datenvisualisierung mit D3.js</h3><p>Im Laufe der letzten Jahrzehnte gewann das Sammeln von Daten enorm an Wichtigkeit. Der Bereich der Datenvisualisierung wird somit immer bedeutsamer. Wir versuchen Daten aufzubereiten, indem wir sie visualisieren. Somit können Daten einfacher interpretiert und ausgewertet werden. Der Browser bietet dabei eine ideale Plattform für die Datenvisualisierung. <a href="https://d3js.org" target="_blank"> D3.js </a>  scheint nach wie vor das Werkzeug der Wahl zu sein, um im Browser Daten zu visualisieren. In der Keynote sprach Shirley Wu über den Einsatz von D3.js zusammen mit SVGs und zeigte ein paar sehr kreative Visualisierungen. In einem weiteren Talk stellte Mirco Zeiß die Grundlagen der Bibliothek vor. Der Sprecher betonte wiederholt, dass man auf den Einsatz der D3.js-Wrapper verzichten und sich stattdessen mit der eigentlichen API auseinandersetzen sollte.</p></div><div><h2>Fazit</h2><p>Die EnterJS 2018 war eine überaus gelungene Konferenz. Sie bot ein breites Spektrum an Themen, die von kompetenten Referenten vorgestellt wurden. Auch die Organisation und Durchführung war sehr professionell und ließ keine Wünsche offen. Für uns bleibt nur noch zu sagen: Wir kommen wieder.</p></div>

EnterJS – Blick ins JavaScript-Universum

<p>Dieser Teil der Blogserie zum Thema <em>Augmented Reality mit der Hololens</em> behandelt, wie ein grundlegendes Unity3D-Projekt aufgebaut wird. Im letzten Blogpost (<a href="/wissens-hub/blog/augmented-reality-mit-der-hololens-wie-funktioniert-das-ueberhaupt">Augmented Reality mit der Hololens</a> ) wurde beschrieben, was die Hololens ist und wie sie funktioniert. Darauf aufbauend wird nun das Aufsetzen eines minimalen Projekts beschrieben. Am Ende dieses Blogposts kann eine einfache 3D-Anwendung erstellt, auf die Hololens deployed und ausgeführt werden.</p><h2>Verwendete Software</h2><p>– Windows 10<br /> – <a href="https://unity3d.com/de/unity/qa/lts-releases">Unity 2017.4.10f1</a> <br /> – <a href="https://visualstudio.microsoft.com/de/downloads/">Visual Studio 2017 Community</a> <br /> – <a href="https://github.com/Microsoft/MixedRealityToolkit-Unity/releases/tag/2017.4.1.0">HoloToolkit-Unity-2017.4.1.0</a> </p><p>Software für die Hololens wird für die Universelle Windows-Plattform (UWP) entwickelt und ist somit ausschließlich für Windows. Die erstellten Apps werden über den Microsoft Store angeboten. Um 3D-Anwendungen zu erstellen, wird empfohlen, die <a href="https://unity3d.com/de" target="_blank">Unity</a>  3D Engine mit der 2017-LTS-Version zu verwenden. In diesem Tutorial wird die Version 2017.4.10f1 genutzt. Um das Projekt im Anschluss zu kompilieren und zu deployen, ist außerdem die Visual Studio 2017 Community-Version notwendig.</p><p>Microsoft stellt mit dem <em>HoloToolkit</em> Erweiterungen für Unity zur Verfügung, mit dem man verschiedene Voreinstellungen für die <em>Scene</em> oder das Projekt anwenden kann. Zudem beinhaltet es verschiedene <em>prefabs</em>, mit denen der Einstieg erleichtert werden soll. <em>prefabs</em> sind dabei templates, mit denen 3D-Modelle, Skripte und Einstellungen zusammengefasst werden und so wiederverwendet werden können.</p><h2>Setup des Projektes</h2><p>Wenn Visual Studio und Unity installiert sind, erfolgt die Erstellung eines neuen Unity-3D-Projekts. Es müssen keine <em>Project Assets</em> hinzugefügt werden. Außerdem kann <em>Analytics</em> deaktiviert werden.</p><p><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/8WB19RKPSCKJ1q70nDmq" alt="New project window screenshot" width="620" height="360" /></p><p>Nachdem das Unity-Projekt geladen ist, kann das Hololens Toolkit (HoloToolkit-Unity-2017.4.0.0.upackage) per Drag and Drop in den <em>Asset Browser</em> importiert werden. Alternativ kann die Erweiterung über „Assets/Import Package/Custom Package…“ hinzugefügt werden. Dieses Toolkit beinhaltet <em>prefabs</em> und Unity-Erweiterungen, die das Erstellen einer Hololens-Anwendung erleichtern. Wenn der Import fertig ist, steht in der Menüleiste der neue Menüpunkt <em>Mixed Reality Toolkit</em> zur Verfügung. Unity startet zwischenzeitlich neu.</p><p>Folgende Einstellungen sollten über das neu hinzugefügte Menü <em>Mixed Reality Toolkit</em> vorgenommen werden:</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/mcVqXF1MQaSBTApQWNZK" alt width="650" height="381" /><br /> Die Einstellungen, die für die Hololens notwendig sind, können über den Menüpunkt <em>Apply Mixed Reality Project Settings</em> vorgenommen werden. Sämtliche Einstellungen kann man auch manuell in den Build und Player Settings ändern. Die hier gezeigte Funktion soll dem Entwickler ein paar Extraschritte abnehmen und den Setup-Prozess vereinfachen.</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/yzm0ofFUR1rudxV9EROT" alt width="650" height="381" /><br /> Über den Menüpunkt <em>Apply UWP Capability Settings</em> werden Rechte bzw. der Zugriff auf Resourcen gewährt, welche die Anwendung benötigt. Ohne dieses Menü findet man die <em>Capability Settings</em> in den <em>Player Settings</em> im Bereich der Universal-Windows-Plattform-Einstellungen.</p><p>Als nächstes sollte die <em>default Camera</em> aus der <em>Scene</em> entfernt werden. Stattdessen kann das <em>HoloLensCamera prefab</em> verwendet werden. Diese liegt unter „HoloToolkit/Input/Prefabs/“. Dieses <em>prefab</em> stellt eine Camera zur Verfügung, die speziell für <em>holographic headsets</em> eingestellt ist. Dazu gehört beispielsweise, dass der Hintergrund nicht mit einer <em>Skybox</em>, sondern schwarz gerendert wird. Weiter wird die <em>Near Clipping Plane</em> verändert, so dass Objekte nur gerendert werden, wenn sie mindestens 0.85 Einheiten in Unity von der Kamera entfernt positioniert wurden. Diese Einstellung lässt sich ändern, gilt jedoch als <a href="https://docs.microsoft.com/en-us/windows/mixed-reality/hologram-stability#hologram-render-distances" target="_blank">empfohlener Maßstab</a> , um ein gutes AR-Ergebnis zu erzielen. Neben diesen Einstellungen bringt das Camera prefab außerdem einen cursor, der in der Mitte des Viewports angezeigt wird und sich durch entsprechende Ausrichtung an die erkannte Umgebung anpasst.</p><p>Damit ist das grundlegende Setup abgeschlossen. Um dieses zu testen kann ein Objekt der <em>Scene</em> hinzugefügt und um 5 Einheiten auf der z-Achse verschoben werden (Translation 0, 0, 5). Wenn alles funktioniert hat, sollte dieses nach dem Deployment und dem Starten der Anwendung auf der Hololens sichtbar sein.</p><p><img loading="lazy" width="700" height="466" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/JuZAyXPnRBaqEXkDgaJz" alt="Initiale Scene mit Würfel" /></p><h2>Deployment auf die Hololens</h2><p>Um die Scene auf der Hololens zu deployen, muss ein Visual-Studio-Projekt erzeugt werden. Dafür öffnet man die Build Settings und ändert die Einstellungen wie im folgenden Bild dargestellt:</p><p><img loading="lazy" width="629" height="611" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/yFiiwL8tRD2qftVbgOdZ" alt="Hololens BuildSettings" /></p><p>Wenn man nun <em>Build</em> anwendet, wird man aufgefordert, einen Speicherort für das Visual-Studio-Projekt auszuwählen. Die erzeugte Solution wird letztendlich zum Bauen und Ausführen der Anwendung benötigt. Öffnet man das gerade erzeugte Projekt in Visual Studio, muss nur noch die Zielarchitektur auf x86 gesetzt werden. Man kann das Deployment über ein USB-Kabel oder über das Netzwerk durchführen. Ist die Hololens per USB-Kabel verbunden, so wählt man <em>Device</em> als Ziel aus. Möchte man ohne Kabel deployen, kann man „Remotecomputer“ auswählen. Im darauffolgenden Fenster kann dann die IP der Hololens eingetragen werden. Anschließend kann man das Projekt über <em>Ctrl+F5</em> (Starten ohne Debugger), bauen und deployen.</p><h2>Testen ohne Deployment</h2><p>Der Umweg über Visual Studio kann bei einfachen Scene-Veränderungen umständlich sein. Um eine Scene direkt auf die Hololens streamen zu können, kann man „Holographic Streaming“ konfigurieren. Um dieses Feature nutzen zu können, muss auf der Hololens die App <em>Holographic Remoting</em> installiert werden. In Unity lässt sich unter <em>Window -> Holographic Emulation</em> eine Streaming-Verbindung einrichten. Mit diesem Setup lässt sich über den Play Button in Unity direkt die Scene auf der Hololens darstellen. Diese Verbindung ist bidirektional. Das heißt, die Scene wird auf die Hololens gestreamt und die Kopfbewegungen werden direkt in Unity angezeigt.</p><h2>Fazit/Ausblick</h2><p>In diesem Blogpost wurde beschrieben, wie ein grundlegendes Projekt aufgesetzt werden kann. Im nächsten Teil werden wir anhand eines realen Showcases erläutern, wie reale Objekte um Mixed Reality erweitert werden können. Abschließend wollen wir nicht nur Objekte in den Raum projizieren, sondern auch mit ihnen interagieren.</p><p>Quellen:<br /> <a href="https://github.com/Microsoft/MixedRealityToolkit-Unity">Hololens Mixed Reality Toolkit</a> </p>

Hololens mit Unity3D: Projektsetup

<p>Im vorherigen Teil der Blogserie zum Thema <em>Augmented Reality mit der Hololens</em> (<a href="/wissens-hub/blog/hololens-mit-unity3d-projektsetup" target="_blank">Hololens mit Unity3D: Projektsetup</a> ) haben wir die Integration der Hololens in die Engine <a href="https://unity3d.com/de" target="_blank">Unity3D</a>  erläutert. Hier wollen wir nun anhand eines Beispiels auf die elementaren Elemente von Unity3D im Umgang mit Mixed Reality und der Hololens eingehen. In diesem Projekt wollen wir eine Maschine um mögliche Wartungsanweisungen ergänzen, diese platzieren und abschließend in Form eines Hologramms anzeigen.</p><p>Ein besonderer Dank gilt an dieser Stelle der Firma <a href="https://www.roeltgen.de" target="_blank">Röltgen</a> , die uns die Maschine mit ihren Wartungsanweisungen zur Verfügung stellte.</p><h2>Component-Entity-System</h2><p>Wie die meisten 3D-Engines setzt auch Unity auf das <em>Entity-Component-System</em>. Dies beschreibt einen Architekturansatz, der auch nach dem <em>composition over inheritance</em> Prinzip agiert. Die Basis bilden hier <em>Entities</em>. Diese beschreiben jegliche Art von Objekten. Dabei ist es egal, ob sie sichtbar oder unsichtbar sind, sich bewegen oder statisch sind. Die <em>Entities</em> können um beliebige Subelemente erweitert werden. Jedes Subelement fügt weitere <em>Components</em> hinzu. <em>Components</em> können Eigenschaften, Funktionen oder Beschreibungen sein. <em>Components</em> können somit auch wiederverwendet und anderen <em>entities</em> hinzufügt werden, ohne Abhängigkeiten zu erzeugen. Somit können komplexe Vererbungen vermieden werden.</p><p><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/X8fprAvEQIm3vdnyeA78" alt="Component-Entity-System" width="620" height="360" /></p><p>Dieses Beispiel zeigt einen Würfel, dem ein <em>Rotator Component</em> zugewiesen wurde. Dieses sorgt dafür, dass sich der Würfel dreht. Eine weitere Komponente, die jede <em>Entity</em> besitzt, ist das <em>Transform</em>. Hiermit kann jedem Element innerhalb einer Scene eine Position, eine Ausrichtung und/oder eine Skalierung gegeben werden.</p><h2>Scene, Events & GameState</h2><p>Die <em>Scene</em> beschreibt die hierarchische Anordnung der Elemente und ermöglicht so das Gruppieren und die Kapselung von Elementen. In diesem Projekt haben wir eine <em>Scene</em> mit den Basiselementen Licht, der <em>HoloLensCamera</em> ausgestattet. Zusätzlich wurden ein <em>HUD</em>, die animierten Wartungsschritte und Spracherkennung unter einen GameStateManager gehängt.</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/I2B2FWWSQteNqlTGujxc" alt="Scene mit GameStateManager" width="620" height="360" /></p><p>Der <em>GameStateManager</em> ist ein Singelton, das die unterschiedlichen Interaktionen mithilfe von Events steuert und zusätzlich den aktuellen State der Anwendung speichert. Triggert die Spracherkennung bei einem Signalwort den <em>GameStateManager</em> für einen Befehl an, dann feuert sie ein Event an alle Subelemente, die die Methode des Events implementieren.</p><p>Das folgende Beispiel zeigt das Erzeugen eines Events im GameStateManger.<br /> </p><p>Dieses Code Snippet zeigt, wie wir ein Event empfangen und verarbeiten.<br /> </p><p>Um die Interaktionen mit den 3D-Objekten ohne Hololens zu erleichtern, haben wir zusätzlich einen <em>DebugController</em> erstellt, der anstatt von Spracherkennung mit Hilfe von Tastatureingaben verschiedene Events auslösen kann. Dieser macht es möglich den Ablauf der Animationen testen zu können ohne die Anwendung in der Hololens deployen zu müssen.</p><h2>Animationen</h2><p>Um Animationen in Unity zu integrieren und abspielen zu können, müssen diese zuvor von einer 3D-Modeling-Software erstellt werden und als .fpx-Datei abgespeichert werden. Anschließend können wir diese Datei per Drag’n’Drop den <em>Assets</em> von Unity hinzufügen. Im Assetbrowser sind so zum einen die einzelnen Modellteile als auch die erstellten Animationen sichtbar (siehe markierte Komponente).</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/cMyxS5iTRO9BxWfdDfw5" alt="Animationen in einer .fpx-Datei" width="620" height="360" /></p><p>Um den Ablauf von Animation zu steuern, erzeugen wir einen <em>AnimationsController</em>, in dem wir einen Start und ein Ende definieren. Der Start und das Ende wird durch Transitions verbunden. Eine Transition beschreibt dabei den Wechsel von einer Animation zur nächsten. Diese Transition können wir noch mit einer Animation aus dem Import verknüpfen. Nachdem wir den Ablauf der einzelnen Animationen definiert haben, übergeben wir diese einer <em>Statemachine</em> und können diese über ein Skript steuern.</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/bAk6AUBzSuuAyR7ShRQp" alt="Animations-Flow" width="310" height="180" /></p><h2>Interfaces in Mixed Reality</h2><p>Während klassische 2D-Anwendungen auf diegetische oder Meta-Interfaces setzen, bieten sich für VR-Anwendungen spatiale Interfaces an. Derartige UIs bieten eine dritte Dimension mit Berücksichtigung der Kamera und werden in der Regel direkt in die Szene integriert. Zu beachten ist dabei, VR-Sickness zu vermeiden. Diese kann auftreten, wenn die körperliche Selbstwahrnehmung von der visuellen Wahrnehmung abweicht, und somit zu Schwindelgefühl führen.</p><p>AR-Anwendungen bieten die Möglichkeit, Interfaces auf unterschiedliche Art und Weise im 3D-Raum zu platzieren. Zum einen können wir das Interface an die Position eines anderen Objektes (body-locked), an eine feste Position im Weltkoordinatensystem binden (world-locked) oder dafür sorgen, dass das Interface immer im Sichtfeld des Anwenders ist (head-locked). Für Letzteres bietet Unity zwei Komponenten an, die die Erstellung eines head-locked HUDs erleichtern. Dazu wird zunächst ein <em>GameObject</em> erstellt und das <em>Billboard Component</em> von Unity hinzugefügt. Diese sorgt dafür, dass der orthogonale Vektor des Interfaces immer in Richtung der Kamera zeigt und führt somit zum gewünschten Head-locked-Effekt. Dies kann mit einem <em>Tag-along</em> Komponente verbessert werden. Diese passt die Bewegung des Interfaces auf eine natürliche Weise an und vermeidet bei richtiger Parametrisierung VR-Sickness.</p><h2>Voice Input</h2><p>Interaktionen mit dem Hologramm erfolgen in diesem Beispiel über Spracheingaben des Anwenders. Dazu nutzen wir die integrierte Unity-Voice API. Hierzu wird ein <em>GameObject</em> erstellt und ein Skript angehängt, das auf die Voice API der Hololens zugreift. Dieses Skript initialisiert einen <em>PhraseRecognizer</em>, dem ein Array an Schlüsselwörtern übergeben wird. Durch die Verwendung der definierten Schlüsselwörter wird ein Event geworfen und die entsprechende Aktion ausgelöst.</p><p></p><h2>Platzierung des Objektes</h2><p>Zur Platzierung des Objektes haben wir uns das <a href="https://docs.microsoft.com/en-us/windows/mixed-reality/spatial-mapping" target="_blank">Spatial Mapping</a>  zu Nutze gemacht. Dabei wird zunächst die Geometrie des Raumes mit der Kamera der Hololens erfasst und somit ein <em>Mesh</em> erstellt. Dieses <em>Mesh</em> wollen wir nutzen, um unser Objekt zu platzieren. Dazu definieren wir eine zusätzliche Hilfsebene, die im Boden liegen soll. Unser eigentliches Objekt setzen wir über unsere virtuelle Hilfsebene mit dem originalen Abstand zwischen Boden und Maschine. Des Weiteren soll unsere virtuelle Ebene direkt an einer Wand-Boden-Kante platziert werden. Somit müssen die unterschiedlichen Ebenentypen Wand, Boden oder Decke identifiziert werden. Insgesamt teilt sich so unsere Anwendung in drei Teile auf. Im ersten Teil wird der Raum gescannt, danach erfolgt die Platzierung der virtuellen Bodenebene an der gewünschten Wand und schließlich die eigentliche Anwendung.</p><p>Dieses Vorgehen wird auch seitens des <em>MixedRealityToolkit</em> unterstützt. Kernelemente sind hier vor allem der <a href="https://docs.unity3d.com/Manual/SpatialMappingRenderer.html" target="_blank"><em>Spatial Mapping Renderer</em></a>  und der<a href="https://docs.unity3d.com/Manual/SpatialMappingCollider.html" target="_blank"> <em>Spatial Mapping Collider</em></a> . Ersteres unterstützt die Visualisierung & Erstellung einer Raumkarte. Der <em>Spatial Mapping Collider</em> dient zur Interaktion mit dem <em>Mesh</em>. Das Labeling des richtigen Ebenentyps erfolgt automatisch nach der Erstellung des <em>Meshes</em>. So können wir abschließend die Hilfsebene ideal an der gewünschten Wand-Boden-Ebene platzieren.</p><h2>Fazit & Ausblick</h2><p>In diesem Blogpost haben wir aufgezeigt, wie man verschiedene Elemente relativ einfach in Unity zu einer Mixed-Reality-Anwendung kombinieren kann. Einen Ausschnitt aus unserem Prototyp könnt ihr hier sehen:</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Q2jaXrXLSV0wanHUxByw"><img loading="lazy" width="359" height="200" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Q2jaXrXLSV0wanHUxByw" alt="Animation" /></a> </p><p>In Zukunft wollen wir noch einige Elemente verbessern. Zum einen wollen wir auf die vorangehenden Schritte zur Platzierung verzichten und den Raum direkt platzieren können. Hier könnte ein Marker-basierter Ansatz helfen. Zum anderen wollen wir mit unterschiedlichen Materialien experimentieren, um die Animationen besser an die reale Szene anzupassen.</p>

Hololens mit Unity3D: Ein Beispielprojekt

Team Lead & IT Consultant 

Knowledge und Task Management in Notion

Lessons learned: Was wir in einem Jahr ML Orchestrierung mit Dagster gelernt haben

IT Consultant / MLOps Engineer

Head of Berlin, Erfurt, Hamburg, Leipzig, Münster

Solution Architect

<p>In diesem Artikel stelle ich das Open-Source Projekt Keycloak vor, ein integriertes Single Sign-On und IDM für RESTful Web Services und Browser Apps.</p><p>Keycloak wird von Red Hat entwickelt und gefördert. Die Projektseiten befinden sich unter <a href="http://keycloak.jboss.org" target="_blank">http://keycloak.jboss.org</a> , die Sourcen sind in GitHub unter <a href="https://github.com/keycloak/keycloak" target="_blank">https://github.com/keycloak/keycloak</a>  zu finden. Lead-Entwickler sind im wesentlichen Stian Thorgersen, Bill Burke und Marek Posolda. Das Produkt ist komplett in Java beschrieben und bedient sich sehr ausgiebig an Red Hats Java Stack. So wird standardmässig WildFly als Applicationsserver eingesetzt und auch die Clustering- und HA-Funktionen von Wildfly werden genutzt.</p><h2>Warum das Ganze?</h2><p>Im Rahmen eines Kundenprojektes bestand die Aufgabe, eine vorhandene Lösung für das Access-Management abzulösen. Es wird eine zentrale, anwendungsübergreifende Authentifizierungslösung („Login“) mit Single-Sign-On-Funktionalität für alle Web-relevanten Anwendungen des Kunden benötigt. Weiterhin besteht der Ausblick auf Mehr-Faktor-Authentifizierungen und Social-Media-Login. Zielvolumen sind mehrere Millionen Online-Nutzer in allen Kontinenten für diverse Webanwendungen des Kunden.</p><p>Während der Evaluierung möglicher Kandidaten für die Ablösung haben wir uns dabei auch mit Keycloak beschäftigt und dieses Produkt letzendlich auch eingesetzt.</p><h3>Was kann Keycloak?</h3><p>Keycloak ist ein Java-basiertes System für Single-Sign-On. Es geht hier im wesentlichen um die Autorisierung für Web-Anwendungen, mobile Anwendungen und REST-Services. Hierfür bietet Keycloak die zentralen Funktionen wie Login, Logout, Selbstregistrierung und auch Mehr-Faktor Authentifizierung an.</p><p>Das System unterstützt für die Anmeldung alle gängigen Verfahren:</p><ul><li>OAuth und OAuth2</li><li>OpenID-Connect</li><li>JWT</li><li>SAML</li><li>Kerberos</li></ul><h3>Realms</h3><p>Innerhalb von Keycloak arbeitet das System mit sog. Realms, pro Realm gibt es eine eigene Benutzerverwaltung, Berechtigung, Workflows und UI-Themes.</p><p>Als Identity-Provider sind im Keycloak pro Realm LDAP und Kerberos als Provider konfigurierbar und Keycloak kann hier auch ein sog. sufficient login, sprich es werden alle Identity-Provider nach der Priorität befragt bis einer von diesen den anmeldenden User kennt (oder auch nicht). Auf diesem Weg kann man mit Keycloak z.B. auch mehrere Datentöpfe für interne User und Web-User in einem Realm nutzen.</p><p>Wer keine Windows-Domäne o.ä. hat und auch keinen zentralen LDAP kann Keycloak natürlich auch ohne Identity-Provider nutzen und alle Benutzer in Keycloak selbst anlegen und nutzen (hierzu gibt es dann z.B. auch die Selbstregistrierung).</p><p><span><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ZQMOY6MMQqiKWSagWm5u"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ZQMOY6MMQqiKWSagWm5u" alt="Realm Overview" width="381" height="314" /></a> </span></p><h3>Wie sieht das aus?</h3><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ZtycFK82TqqOEvBoHtGU"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ZtycFK82TqqOEvBoHtGU" alt="Keycloak 1.9.5 main screen" width="606" height="315" /></a> </p><h2>Hochverfügbarkeit und Skalierbarkeit</h2><p>Wie in der Einleitung bereits erwähnt setzt Keycloak sehr stark auf den Basisfunktionalitäten von WildFly auf. Hierzu gehört auch die Nutzung von Infinispan als Cache-Subsystem. Dies erlaubt es, alle relevanten Informationen über Benutzersessions zu n Clusternodes zu replizieren. Dies erlaubt es dem Loadbalancer, bei Ausfall des angesprochenen Knotens einfach einen anderen auszuwählen und auch dieser verfügt über alle Sessions. Die Praxis hat gezeigt, dass dies bei einem Cluster mit sechs Knoten und voller Replikation über alle Knoten perfekt funktioniert und wir im laufenden Betrieb einzelne Server ohne Auswirkung auf die Benutzer herunterfahren oder neustarten können.</p><p>Für die Persistenzschicht nutzt Keycloak entweder Hibernate oder aber MongoDB als dokumentenbasierte Datenbank.</p><p>Wir haben uns hier beim Kunden für ein MongoDB-Replikaset mit einem Master und fünf Slaves entschieden, dieses wird vom Mongo-Treiber direkt unterstützt und wir können ohne Arbitrator immer den gerade aktiven Master nutzen (ausserdem ist es extrem einfach installierbar und auch von Ansible gut unterstützt).</p><p>Da Keycloak selbst nur die Benutzerkonten, Realmkonfigurationen etc. aber die SessionInformationen in der Persistenzschicht speichert, kommt hier keine grosse Last auf und dieses Konstrukt funktioniert einwandfrei.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FyyFRDPxQFbtJJ71vbfy"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/FyyFRDPxQFbtJJ71vbfy" alt="keycloak HA" width="669" height="361" /></a> </p><h2>Installation und Konfiguration</h2><p>Ein Vorteil von Keycloak ist es, dass man die gesamte Konfiguration des Servers per Admin-API durchführen kann.<br /> Wir nutzen <a href="/wissens-hub/blog/nicer-ansible-output-for-puppet-tasks">Ansible</a>  für Installation und Konfiguration unserer Umgebung, hierbei kommen sämtliche konfigurative Artefakte aus dem Git des Kunden. Dies bietet uns den Vorteil, dass wir „nackte“ Keycloak Server per Ansible auspacken und die gesamte Konfiguration aus den Playbooks und Inventories heraus vornehmen können. In Folge dieses Vorgehens machen wir auch keine Updates mehr, sondern löschen die bestehende Installation und setzen diese inklusive der gesamten Konfiguration per Ansible einfach neu auf !</p><p> </p><h3>Ausblick</h3><p>In weiteren Blogartikeln wollen wir folgende Details von und mit Keycloak vorstellen:</p><ul><li>Single Sign On mit Keycloak</li><li>Nutzung von Authenticating Proxies mit Keycloak (mod_saml und mod_openidc)</li><li>API Security mit Keycloak</li><li>Mehr-Faktor-Authentifizierung</li><li>Social-Medial Login</li></ul><p>Einen weiteren Artikel zu diesem Thema finden Sie übrigens auch bei uns auf der Website. Jannik Hüls hat einen Artikel über <a href="https://www.codecentric.de/publikation/automatisiertes-access-management-mit-keycloak/" target="_blank">Automatisiertes Access-Management</a>  geschrieben.</p>

Access Management mit Keycloak

Solutions & Sales

Senior IT Consultant

<p>Wir hatten ja schon mal hier im Blog über eine Methode berichtet, um eine Sprint-Retrospektive anders zu gestalten. Da ging es darum, den Sprint als Bild darzustellen – <a href="/wissens-hub/blog/sprint-reflection-mal-anders">Sprint Reflection mal anders</a> . Ich möchte mit diesem Blogeintrag eine weitere Idee für Retrospektiven abseits des klassischen „was lief gut?“ und „was können wir verbessern?“-Flipcharts vorstellen.</p><p>Vor einiger Zeit hatte ich die Gelegenheit, eine Retrospektive für eines unserer Scrum Teams zu moderieren. Da ich wenig Vorbereitungszeit hatte, dachte ich zunächst an eine der klassischen Methoden für Retrospektiven*. Morgens beim Kaffee kam mir dann aber die Idee für eine Variation der ich den Titel „Unser Sprint bei Amazon“ gab. Es geht nicht darum einen Sprint zu verkaufen, wie man vielleicht auf die Schnelle vermutet. Nein, es geht um eine Analogie zu Kundenrezensionen und die sind am Beispiel Amazon leicht erklärbar, da sie jeder kennt.<span></span></p><p>Aber zurück zum Ablauf der Retrospektive: Nach einer kleinen Einstiegsfrage für die Eröffnung der Retrospektive haben wir eine Timeline des letzten Sprints erstellt. Dies diente nur dem Zweck, den Sprint noch mal in Erinnerung zu rufen. Anschließend habe ich den Teilnehmern eine Aufgabe gestellt, die wie folgt lautete:</p><blockquote><p>Stellt euch vor ihr seid bei Amazon und findet dort den letzten Sprint. Es gibt leider noch keine Kundenrezension zu dem Sprint, also schreibt ihr die erste.</p></blockquote><p>Die Teammitglieder sollten in einer Timebox von 10 Minuten eine Amazon Kundenrezension des Sprints schreiben. Dazu gehörten nach meiner Vorgabe:</p><blockquote><p>1. Eine Überschrift für den Sprint<br /> 2. 1 bis 5 Sterne für den Sprint<br /> 3. Sachen die gut liefen und somit an Leser der Rezension weiterempfohlen werden können<br /> 4. Sachen die besser gemacht werden können, an denen man also arbeiten muss</p></blockquote><p>Nach Ablauf der Timebox lasen alle ihre Rezensionen vor bzw. fassten ihre Stichpunkte zusammen. Ich als Scrum Master notierte alle Überschriften und Sterne auf einem Whiteboard. Den Inhalt der Rezensionen, was gut war und was verbessert werden kann, notierte ich ebenfalls in Stichpunkten auf dem Whiteboard.</p><p>Die letzten zwei Punkte sind klassisches Information-Gathering. Die ersten zwei Punkte bringen aber meist erstaunliche Ergebnisse. Die Teilnehmer sind beim Erstellen der Überschrift gezwungen, die letzten Wochen auf einen Satz zu komprimieren, was eine extreme Schwierigkeit darstellt. Das fördert die individuelle Reflektion der letzten Iteration und bringt die Meinung des Teilnehmers auf den Punkt. Der zweite Teil, die Bewertung über Sterne, gibt zusätzlich eine extrem komprimierte Information wie der letzte Sprint lief. Zwischen 1 Stern = schlecht und 5 Sterne = hervorragend muss sich jeder festlegen. Die Gründe für die Sternvergabe fließen in die ersten Teile der Rezension. Über die vergebenen Sterne hat man zudem eine einfache Möglichkeit einen Schnitt zu bilden und so den Gesamteindruck des Teams vom letzten Sprint zu erkennen.</p><p>Da die notierten Stichpunkte zu zahlreich waren um alle eingehend zu diskutieren, führten wir ein Clustering nach Themen durch. Über die Themen stimmten wir per Dot Voting ab, um die Top Themen zu identifizieren, die eingehender betrachtet werden sollten. Anschließend diskutierten wir die Top Themen, jeweils durch eine Timebox beschränkt, und erarbeiteten Maßnahmen um die Arbeit im Team zu verbessern.</p><p>Die Erarbeitung der Maßnahmen soll jedoch nicht im Mittelpunkt dieses Blogbeitrags stehen. Mittlerweile habe ich diese Art von Retrospektiven schon bei mehreren Kunden und bei verschiedenen Teams der codecentric durchgeführt. Sie funktionierte jedes Mal sehr gut und ich kann sie nur weiterempfehlen. Für Kanban Teams kann man eine solche Retrospektive auch machen. Man schreibt dann natürlich nicht über den letzten Sprint, sondern über die Zeit seit der letzten Retrospektive.</p><p> </p><p>* Mit klassischen Methoden für Retrospektiven meine ich Methoden wie sie z.B. in „Agile Retrospectives: Making Good Teams Great“ von Esther Derby & Diana Larsen beschrieben werden. Nebenbei: Ein sehr zu empfehlendes Buch für den Einstieg in das Thema Retrospektiven.</p><p> </p>

Unser Sprint bei Amazon

Atlassian Expert / Agile Coach

Consultant & Software Engineer

Produktentwicklung SHERLOQ

<p>In this article I want to share with you how <a href="https://github.com/spulec/moto" target="_blank">moto</a>  hooks into boto3 and how you can use it to test existing Python code which interacts with your AWS infrastructure.<br /> Recently I have been in a project in which we were working on machine learning pipelines within an AWS architecture. When I joined the project some of the code was already present, but untested. I did not feel comfortable to change and deploy it. That is why I started with setting up tests to better understand what is going on and to be able to change the code in a controlled fashion.</p><h2>Why moto is a good fit</h2><p>The code I wanted to test was written in Python and running on AWS infrastructure within Docker containers. Interaction with the AWS infrastructure was implemented with <a href="https://pypi.org/project/boto3/" target="_blank">boto3</a> , the AWS SDK for Python. The initialization of the aws-access happened somewhere within the functions I wanted to test.</p><p>Moto is a good fit in such a case, because it enables you to mock out all calls to AWS made in your code <em>automatically</em>.<br /> There is no need for dependency injection. You can take the code you have in place and test it straight away. You <em>just</em> need to enable motos mocking functionality and take some precautions, that is it.</p><p>In the following I will show how to enable moto and what precautions to take.</p><h2>How does moto actually mock things?</h2><p>The main hook for moto into boto3 is a global <a href="https://github.com/boto/botocore/blob/master/botocore/handlers.py" target="_blank">list of handlers (named BUILTIN_HANDLERS)</a>  in botocore, which is the foundation of boto3.<br /> All handlers within this global list are registered every time <a href="https://github.com/boto/botocore/blob/master/botocore/session.py" target="_blank">a session is instantiated</a> . Once an internal event is emitted, the handlers registered for that kind of event are called.</p><p>A <em>before-send</em>-handler for example is executed just before an actual http-request is being send to AWS. If a <em>before-send</em>-handler returns a response, it is used for further processing and the http-request itself is skipped.</p><p>This is an example on how to skip http-requests in botocore by returning mock-responses in a custom <em>before-send</em>-handler:</p><div>

```python
from botocore.awsrequest import AWSResponse
from botocore.handlers import BUILTIN_HANDLERS
from moto.core.models import MockRawResponse
 
def my_custom_handler(request, event_name, **kwargs):
    # event_name is sth like 'before-send.s3.GetObject'
    return AWSResponse('',200,{},MockRawResponse(''))
 
BUILTIN_HANDLERS.append(("before-send", my_custom_handler))
```

</div><p>Moto <a href="https://github.com/spulec/moto/blob/master/moto/core/models.py" target="_blank">appends</a>  such a <em>before-send</em>-handler to the BUILTIN_HANDLERS. The handler is used to return mock-responses from moto mock backends we register. It is appended implicitly, when importing moto in your test code, but does not return (mock) anything by default. Mocking can be achieved by using moto-decorators (or any of the other initializations of moto), which are available for most of the AWS resources.</p><p>The moto-decorator registers a mock backend for the scope of the test function. The mock backend is used by the appended <em>before-send</em>-handler to return mock responses. Keep in mind, that the moto-decorator enables the mocking only for the scope of your test function. After your test passes, mock backends and testing credentials are being reset by moto.</p><h2>Setting up moto and protecting your AWS environment</h2><p>Interesting, so what happens if I import moto in my test code, but forget to use the moto decorator?<br /> A missing moto decorator might cause changes in your AWS environment if you did not take precautions. Even though moto might have registered the handler in time implicitly, the mock backend would not be initialized and your code would try to access AWS.</p><p>That is why you should stick to the <a href="https://github.com/spulec/moto#very-important----recommended-usage" target="_blank">recommended usage</a>  of moto:</p><ul><li>run your tests with testing-credentials</li><li>set up mocking <b>before</b> any usage/import of boto3</li></ul><p>If you fail on setting up the mocks correctly, the testing credentials will still protect you from changing things in your AWS environment.</p><p>To be able to properly secure our test setup and provide test credentials to protect our AWS environment, we need to understand how boto3 accesses credentials.</p><p>Every time you instantiate a client with boto3, boto3 tries to find credentials to use for accessing AWS. You can see that if you activate the debug-logs for <em>botocore.credentials</em> or you can have a look in the documentation <a href="https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html" target="_blank">here</a> .</p><div>

```python
import logging
import boto3
 
boto3.set_stream_logger('botocore.credentials', logging.DEBUG)
client = boto3.client('s3')
```

</div><p>Would print something like:</p>

```
[DEBUG] Looking for credentials via: env
[DEBUG] Looking for credentials via: assume-role
[DEBUG] Looking for credentials via: assume-role-with-web-identity
[DEBUG] Looking for credentials via: shared-credentials-file
[INFO] Found credentials in shared credentials file: ~/.aws/credentials

```

<p>Boto3 looks at parameters passed during initialization in your code first. Secondly it checks if AWS environment variables have been set. Afterwards credentials, config files, … are being parsed.</p><p>Now after we know how moto hooks into boto3 and how credentials are being read, these are some precautions steps which should help us to set up a safe test environment which won’t interact with our AWS environment:</p><h3>1. No parameters when initializing AWS access within the code</h3><p>Passing no parameters to boto3 when initializing AWS access makes sure we can influence the connection from outside. For example by setting environment variables.</p><div>

```python
client = boto3.client('s3')
```

</div><h3>2. Initialize AWS access within a function</h3><p>It is crucial to be able to control when exactly the AWS access is initialized and boto3 looks for credentials. Especially because the moto import in our test file implicitly appends a mock handler in botocore, which should be picked up by the boto3 initialization. The easiest way to do this is to have the initialization within a function in your scripts/applications code.</p><div>

```python
import boto3
 
def start():
    client = boto3.client('s3')
```

</div><p>If you have it outside of a function and import your code in your test file, the import statement alone would cause the access to be initialized due to Pythons <a href="https://docs.python.org/3/library/__main__.html" target="_blank">module</a>  <a href="https://docs.python.org/3/reference/import.html#loaders" target="_blank">loading</a> . The ordering of your import statements would determine whether or not motos <em>before-send</em>-handler got registered within your client. That is why moto recommends to use inline imports when you have not wrapped your initialization in a function.</p><h3>3. Initialize moto backends before you call your code</h3><p>Once we made sure our initialization picked up the moto handler, we still need to register and activate mock backends in moto. If we don’t, our handler would not return mock responses and the requests might reach AWS. Moto initialization can be done in different ways. I prefer the decorator which is quite convenient.<br /> The decorator adds and activates a mock backend for our test function, in this example a s3-backend.</p><div>

```python
from moto import mock_s3
from unittest import TestCase
 
class TestS3(TestCase):
 
    @mock_s3
    def test_s3(self):
        run_s3_code()
```

</div><p>Keep in mind that calls to other backends could still reach AWS if you do not initialize the moto mocks.</p><h3>4. Set testing credentials before you run your tests</h3><p>It is still possible that you forget about your decorator or initialize a client on top level within your code, which would not pick up the moto handler. Because all this might happen it makes sense to be careful and take additional precautions.</p><p>Once you are in a moto testing block (for example test function with moto decorator), you are pretty safe. Moto itself sets testing credentials in the environment if you have at least one mock backend initialized. These credentials are being read by all boto3 initializations within your test code.</p><p>It is still a good idea to have some setup code or fixture (if you use pytest), which sets invalid AWS credentials before the test starts to run. This helps you even if you forget about the moto-decorator. If you have module code which gets executed on import, this still might not protect you. Then again it depends on what comes first. The initialization of the client or the AWS-credentials in the environment.</p><p>As a solution I personally prefer a layered approach:</p><ul><li>testing credentials within your code</li><li>testing credentials within the default-profile of your <em>~/.aws/credentials</em> file (fallback)</li></ul><p>Every time I execute some code accidentally, forget to initialize moto or anything else, boto3 in worst case would fallback to my credentials file at some point and pick up these invalid testing credentials. In cases where I really want to access AWS I work with profiles.</p>

```
[default]
aws_access_key_id=testing
aws_secret_access_key=testing

[codecentric]
aws_access_key_id=some_id
aws_secret_access_key=some_key

...

```

<p>Testing credentials can of course also be set in bash scripts which execute tests, IDE run configurations, pipelines, …</p><h2>Example</h2><p>Knowing all this, lets look at a specific case and see if we understand what is going on.</p><div>

```python
import boto3
 
client = boto3.client('s3') # done outside the method for demonstration purpose
 
def run_s3_code():
    buckets = client.list_buckets()['Buckets']
```

</div><p>What is going on when we run the test? Would it access AWS or not and why?</p><div>

```python
from moto import mock_s3
from s3.s3_code import run_s3_code
from unittest import TestCase
 
class TestS3(TestCase):
 
@mock_s3
def test_s3(self):
    run_s3_code()
```

</div><p>The answer is, it would not access AWS. So what is going on here?</p><h3>1. moto <em>before-send</em>-handler</h3><div>

```python
from moto import mock_s3
```

</div><p>The very first line of our code is the moto import.<br /> This line implicitly adds the <em>before-send</em>-handler within botocore which would not return anything yet.</p><h3>2. boto3 client initialization</h3><div>

```python
from s3.s3_code import run_s3_code
```

</div><p>The second line causes the initialization of our client which we did not wrap in a function. On initialization the global handlers are registered, also the <em>before-send</em>-handler which is already present (1.).</p><h3>3. adding moto backends</h3><div>

```python
@mock_s3
def test_s3(self):
```

</div><p>The decorator adds and initializes a mock-backend which will be used by the <em>before-send</em>-handler. All code we execute within the test function now which uses our client to access s3, would reach the mock-backend instead of AWS.</p><hr /><p>So what happens if we change the order of imports in a way that</p><div>

```python
from moto import mock_s3
from s3.s3_code import run_s3_code
```

</div><p>becomes</p><div>

```python
from s3.s3_code import run_s3_code
from moto import mock_s3
```

</div><p>Right. We would access our AWS environment when running the test. Our client would get initialized first and would not register motos <em>before-send</em>-handler. Be careful here and stick to the recommendations: Initialize your AWS access within a function.</p><h2>Testing code with mocked s3 interaction</h2><p>Once we setup and secured our testing setup, we can start to write tests.<br /> A simple test could look something like this:</p><div>

```python
import json
from unittest import TestCase
import boto3
from moto import mock_s3
from s3.s3_code import run_s3_code
 
class TestS3(TestCase):
 
    @mock_s3
    def test_s3(self):
        bucket = 'test-bucket'
        s3_client = boto3.client('s3')
        s3_client.create_bucket(Bucket=bucket)
 
        # GIVEN
        s3_client.put_object(Bucket=bucket,
                             Key="market_a/market_infos.json",
                             Body=json.dumps({
                                 'products': [
                                     {'price': 150},
                                     {'price': 250},
                                 ]
                             }))
 
        # WHEN
        run_s3_code()
 
        # THEN
        result = int(s3_client.get_object(Bucket=bucket,
                                          Key="market_a/total_price.txt")['Body'].read())
        self.assertEqual(result, 400)
```

</div><p>The tested code:</p><div>

```python
import json
 
import boto3
 
def run_s3_code():
    client = boto3.client('s3')
 
    market_infos = client.get_object(
        Bucket="test-bucket",
        Key="market_a/market_infos.json"
    )['Body'].read().decode('utf-8')
 
    client.put_object(
        Bucket="test-bucket",
        Key="market_a/total_price.txt",
        Body=str(sum(map(lambda a: a['price'], json.loads(market_infos)['products'])))
    )
```

</div><h2>Summing up</h2><p>When testing your code which interacts with AWS using moto, you want to make sure that there is no real interaction with AWS. In order to do that you should</p><ul><li>put your initialization into functions</li><li>initialize moto mocking properly</li><li>setup testing-credentials in your code and your local default-profile</li></ul><p>Moto has been around for quite some time and is a very convenient library to mock AWS services. If you don’t use Python it also has a <a href="http://docs.getmoto.org/en/latest/docs/server_mode.html" target="_blank">stand-alone server mode</a>  which you can use.</p><p>Are you using moto? What are your experiences?</p>

Testing AWS Python code with moto

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

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

Smart DistancR – Perspektivisch korrekte Distanzmessung zwischen Personen

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

# Was genau ist neu in React 19?

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

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

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

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

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

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

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

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

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

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

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

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

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

```
"use server";

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

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

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

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

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

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

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


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

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

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

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

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

### Weitere Features und Hooks

**Ref als Prop**

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

**useOptimistic**

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

**useFormStatus**

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

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

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

# Quellen

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

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

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

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

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

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

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

# What exactly is new in React 19?

## Introduction of a New Compiler

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

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

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

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

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

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

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

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

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

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

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

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

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

```
"use server";

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

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

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

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

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

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

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


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

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

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

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

### Additional Features and Hooks

**Ref as Prop**

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

**useOptimistic**

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

**useFormStatus**

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

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

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

# Sources

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

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

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

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

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

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

<p>Was macht codecentric für Studenten besonders interessant? Wie ist eigentlich der Umgang zwischen den Kollegen? Was gefällt den Studis bei codecentric besonders gut? Um diese und weitere Fragen geht es in der aktuellen Folge <em>Eine Mate mit</em>. Hier berichten die beiden Studis Johanna und Michel kurz und knapp über ihre Erfahrungen als Studenten bei codecentric.</p><p></p><div><div><div> <img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/BU1j0LaBTJCF29q2aDnU" alt="Johanna Nolte - Ein Mate mit"/><div>
<a href="https://www.youtube.com/watch?v=erb6XG3W9Ik"> Hier geht es direkt zum Video auf Youtube</a>
</div></div><p><em>Eine Mate mit </em>ist ein Format, in dem verschiedenste Menschen aus der IT-Branche aus ihren Projekten und von ihren Erfahrungen erzählen. Ob Speaker auf einem bei der codecentric gehosteten Meetup, ob Kollegen, ob Konferenz-Dauergäste oder das Arbeitstier aus dem letzten Projekt. Die Gemeinsamkeit der Interviews: <strong>kurz, knackig, auf den Punkt</strong>.</p><h3>#Eine Mate mit – IT-Wissen kurz und erfrischend</h3><p><em>Eine Mate mit</em> möchte Interesse wecken, an Themen und Menschen. Und wer sich danach weiter mit dem Thema beschäftigen möchte, findet weiterführende Links direkt am Ende des Videos und im jeweils zugehörigen Blog-Artikel.</p><p>Wir freuen uns auf eure Kommentare hier im Blog, auf Twitter unter #EineMateMit oder auf YouTube. Sagt uns eure Meinung zu dem Format, wünscht euch Themen und diskutiert mit. Wir werden in den nächsten Monaten regelmäßig neue Folgen veröffentlichen. Jeweils hier auf dem codecentric-Blog und auf YouTube.</p><h2>Mehr zum Thema Studierende bei codecentric</h2><p>Interesse am Thema Studis bei codecentric? Dann schau doch einfach auf unserer <a href="https://www.codecentric.de/karriere">Karriere-Seite</a>  vorbei! Wenn du weitere Infos zum Thema Karriere bei codecentric möchtest, schau gerne in unserem <a href="https://www.codecentric.de/karriere/kultur">Kulturbereich</a> vorbei. Wenn du Fragen hast, sprich uns gerne an. Wir freuen uns darauf, dich kennenzulernen! 🙂</p><p></p>

Studierende bei codecentric | Eine Mate mit … Johanna & Michel #EineMateMit

<p>Infrastructure as Code (IaC) ist heutzutage aus der modernen IT-Landschaft nicht mehr wegzudenken. Red Hat beschreibt den Begriff wie folgt:</p><p><em>Infrastructure as Code (IaC) is the managing and provisioning of infrastructure through code instead of through manual processes. With IaC, configuration files are created that contain your infrastructure specifications, which makes it easier to edit and distribute configurations. It also ensures that you provision the same environment every time.</em></p><p><img width="1024" height="479" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Cp2pByP8RfeM89JGzBQb" alt="Infrastructure as Code am Beispiel von Keycloak mit Terraform" /></p><p><span>Im Grunde geht es darum, die Infrastruktur nicht mehr über UIs „zusammenzuklicken“. Stattdessen wird sie in Form von deklarativen textbasierten Codebausteinen formuliert, sodass jederzeit ersichtlich ist, was genau konfiguriert wurde. Durch die Textform ist bei Verwendung eines Versionierungstools, wie zum Beispiel Git, jederzeit nachvollziehbar, was wann geändert wurde. </span></p><h2><b>Terraform</b></h2><p><span>Ein beliebtes Tool, um IaC umzusetzen, ist </span><a href="/wissens-hub/blog/infrastructure-as-code"><span>Terraform</span></a> <span> von Hashicorp. In Terraform beschreibt man Konfigurationen über sogenannte Ressourcen, die wiederverwendbare und konfigurierbare Bausteine darstellen. Diese Ressourcen können dann über Provider auf eine Zielumgebung angewendet werden. Es gibt viele verschiedene Provider, die eingebunden werden können. Ein klassisches Anwendungsgebiet sind automatisierbare Deployments als Kombination verschiedener Dienste und Infrastrukturkomponenten in einer Cloud wie zum Beispiel Azure, AWS oder auch GCP. Neben der Provisionierung von Cloud-Ressourcen bietet Terraform auch die Möglichkeit, </span><a href="https://registry.terraform.io/" target="_blank"><span>zahlreiche Anwendungen und Dienste</span></a> <span> zu konfigurieren. So wird Terraform für die Konfiguration verschiedener Anwendungen verwendet. In diesem Artikel nutzen wir Terraform, um eine Keycloak-Instanz zu konfigurieren. </span></p><h2><b>Keycloak</b></h2><p><a href="/wissens-hub/blog/single-sign-mit-keycloak-als-openid-connect-provider"><span>Keycloak</span></a> <span> ist eine Open-Source-Identity- und Access-Management-(IAM-)Lösung, welche die Standards OpenID Connect, OAuth 2.0 und SAML 2.0 unterstützt. Der Einsatz von Keycloak bietet den Vorteil, dass sich Entwickler nicht selbst um die Implementierung klassischer IAM-Features wie User Management, Login, Registrierung oder auch die „Passwort-vergessen“-Funktionalität kümmern müssen. Damit lassen sich eigene Anwendungen leicht um einen zentralen Login erweitern, der Single Sign-On (SSO) unterstützt. Zusätzlich bietet Keycloak einen starken Fokus auf Sicherheit und weist eine robuste Implementierung auf. Ein vergleichbares Sicherheitsniveau kann im Falle einer eigenen Implementierung der oben genannten Funktionalitäten nur unter verhältnismäßig hohem Aufwand aufgebaut werden. </span></p><p><span>In diesem Beispiel werden ein Realm und ein Client angelegt, um die grundlegende Verwendung von Terraform für Keycloak zu verdeutlichen. Ein Keycloak-Realm ist eine Art Container für Benutzer, Anwendungen und Login-Verfahren. Realms stellen die oberste Ebene dar, auf der Keycloak logisch unterteilt werden kann. Im einfachsten Fall gibt es in einem Projekt einen Realm für die gesamte Anwendungslandschaft in einer Umgebung. Es lassen sich jedoch auch komplexere Strukturen über Realm-Beziehungen abbilden. Abhängig von den jeweiligen Anforderungen ist auch ein Multi-Realm-Setup möglich. Innerhalb eines Realms sind die geschützten Anwendungen als Clients hinterlegt. Ein Client kann hierbei je nach Art der Anwendung unterschiedlich gestaltet sein. In einer modernen Microservice-Architektur gibt es in der Regel eine Vielzahl von Services. Häufig bietet es sich an, pro Service einen dedizierten Client zu definieren. Diese Clients können dann so konfiguriert werden, wie die Anforderungen des jeweiligen Services es erfordern (z. B. eine mobile App, ein Web-Frontend, ein Backend-Service).</span></p><p><img loading="lazy" width="1024" height="715" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Iu0wk3QvSZeM9sXo5bcA" alt="Keycloak Konfiguration mit Terraform" /></p><p><span>Eine Basiskonfiguration von Keycloak mit Terraform ist einfach und schnell gemacht (vorausgesetzt, dass Docker und Terraform bereits installiert bzw. in der CI-/CD-Pipeline verfügbar sind 🙂). In unserem Beispiel läuft Keycloak lokal in einem Docker-Container, in dem wir mittels Terraform einen Realm verwalten wollen. Der Container kann allerdings auch in die Cloud deployt werden, sodass Keycloak aus dem Internet heraus erreichbar ist. Zunächst laden wir uns das Docker Image von Red Hats Docker Repository </span><a href="https://quay.io/" target="_blank"><span>quay.io</span></a> <span> herunter und starten den Container, in dem Keycloak läuft. </span></p>

```
docker run -e KEYCLOAK_USER=admin -e KEYCLOAK_PASSWORD=secret -p 8080:8080 quay.io/keycloak/keycloak:12.0.3

```

<p><span>Et voilà – schon läuft der Keycloak (im Docker-Container) und kann unter http://localhost:8080 erreicht werden. </span></p><p><img loading="lazy" width="1024" height="494" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/22z5mQwUSS86EmYeyMxw" alt="Keycloak vor dem Konfigurieren" /></p><p><span>Als nächstes erstellen wir einen Ordner</span> <span>keycloak-config</span><span> in dem wir unsere erste Terraform Datei</span><span> main.tf</span><span> für die Konfiguration angelegen. Diese Datei bildet den zentralen Einstiegspunkt für unsere Terraform-Konfiguration. Im Kontext von Terraform stellt der Ordner ein Terraform-Modul dar, das wir mit entsprechenden Resource-Definitionen in Form von Terraform-Dateien ausstatten.</span></p><p><span>./keycloak-config/main.tf</span></p><p></p><p><span>In unserem Beispiel speichern wir den Zustand (Terraform State), den Terraform während der Provisionierung der Ressourcen erzeugt, lokal ab. Dies ist für lokale Testprojekte kein Problem, sollte aber in produktionsnahen Szenarien anders gelöst werden. </span></p><p><span>In einem Produktiv-Szenario ist das Ablegen des Terraform States an einem zentralen Ort, z. B. einem AWS S3 Bucket oder einem GCP Storage Bucket, empfehlenswert. Der Terraform State enthält den Zustand aller von Terraform überwachten Ressourcen. </span></p><p><span>Ein zentral verwalteter State erleichtert die Nutzung von Terraform in einer CI-/CD-Pipeline. Dabei ist zu beachten, dass Konflikte durch parallele Provisionierungen durch mehrere Entwickler oder Pipelines mittels </span><a href="https://www.terraform.io/docs/language/state/locking.html" target="_blank"><span>State Locking</span></a> <span> verhindert werden müssen.</span></p><p><span>Außerdem ist es in einem realen Szenario empfehlenswert, die Terraform-Module übersichtlich zu strukturieren. Best Practices zur Strukturierung von Terraform-Projekten sind <a href="https://www.terraform-best-practices.com/code-structure" target="_blank">hier</a>  zu finden. </span></p><h2><b>Folgendes passiert in dem Code</b></h2><p><span>In dem hier gezeigten Use Case wird der </span><a href="https://registry.terraform.io/providers/mrparkers/keycloak/latest/docs" target="_blank"><span>Keycloak Terraform Provider</span></a> <span> eingebunden. Im Hintergrund verwendet der Provider die </span> Keycloak Admin REST<span>-API, um die Keycloak-Instanz zu konfigurieren. Dazu wird der Provider mit den Zugangsdaten der Keycloak-Instanz, die unter http://localhost:8080 läuft, initialisiert. Weitere Möglichkeiten zum Zugriff von Terraform auf Keycloak findet man </span><a href="https://registry.terraform.io/providers/mrparkers/keycloak/latest/docs#keycloak-setup" target="_blank"><span>hier</span></a> <span>.</span></p><p><b>Achtung! Im Beispielcode sind das Passwort und der Username <em>hard-coded</em> enthalten, um das Beispiel so kurz und anschaulich wie möglich zu halten. In einem realen Produktions-Setup sollte man aus Sicherheitsgründen keine Passwörter in Konfigurationsdateien verwalten. Stattdessen wird empfohlen, ein entsprechendes Secret Management zu verwenden. Beispielsweise können die Credentials über Terraform-Variablen hereingereicht werden. Die CI-/CD-Pipeline befüllt dann diese Variablen.</b></p><p><span>Im Folgenden erstellen wir für unser Beispiel einen Realm und einen Client. Viele Möglichkeiten, Keycloak mit Terraform zu konfigurieren, sind in der </span><a href="https://registry.terraform.io/providers/mrparkers/keycloak/latest/docs" target="_blank"><span>Dokumentation des Providers</span></a> <span> zu finden. Es sei hier jedoch angemerkt, dass nicht alle Features von Keycloak unterstützt werden. Beispielsweise kann man Stand heute (terraform 2.2.0) keine Default Realm Roles mit dem Terraform Provider definieren.</span></p><p><img loading="lazy" width="1024" height="591" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/06noAR0RjGQaLr54me6X" alt="Anwendung der Konfiguration" /></p><p><span>Momentan ist in dem Keycloak nur der Master Realm zu sehen. Das ändert sich, sobald wir unser Terraform Script anwenden. Dazu gehen wir nach dem klassischen </span><a href="https://www.terraform.io/guides/core-workflow.html" target="_blank"><span>Terraform Workflow</span></a> <span> vor.</span></p><p><img loading="lazy" width="1024" height="757" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/gkGTyzeRX6mnAtkYq0MQ" alt="Keycloak vor dem Konfigurieren" /></p>

```
terraform init
```

<p><i><span>terraform init</span></i><span> initialisiert Terraform in unserem Ordner. Dabei analysiert Terraform unsere Konfiguration und lädt etwaig benötigte Provider nach.</span></p>

```
terraform validate
```

<p><span>Nachdem unser Projekt initialisiert ist, bietet es sich an, mit </span><i><span>terraform validate</span></i><span> die Syntax unserer Konfiguration zu prüfen.</span></p>

```
terraform plan -out=local.plan
```

<p><span>Dann zeigt </span><i><span>terraform plan</span></i><span> eine Übersicht dessen, was konfiguriert werden würde, wenn </span><i><span>terraform apply</span></i><span> aufgerufen würde. Das ist wichtig, weil so sichergestellt werden kann, dass genau die gewünschte Konfiguration angewandt wird. So werden eventuelle Konflikte durch unterschiedliche Konfigurationszustände (States) verhindert. Sollte sich der State zwischen </span><i><span>terraform plan </span></i><span>und</span><i><span> terraform apply </span></i><span>ändern, kann das zu Problemen beim Anwenden der Konfiguration führen. So eine Situation kann zum Beispiel durch die gleichzeitige Verwendung mehrerer Benutzer auftreten.</span></p>

```
terraform apply -input=false local.plan
```

<p><i><span>terraform apply</span></i><span> führt schließlich die Konfiguration aus. Der Parameter </span><i><span>-input=false</span></i><span> sorgt dafür, dass das Anwenden der Terraform-Skripte ohne manuelle Bestätigung durchläuft. Dies ist für die Verwendung in einer CI-/CD-Pipeline besonders wichtig.</span></p><p><img loading="lazy" width="1024" height="839" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/zjUIknAT7aLk11ytXGgR" alt="Keycloak nach dem Konfigurieren" /></p><p><span>Nun sind der neue Realm und Client im Keycloak unter http://localhost:8080 zu sehen – fertig!</span></p><h2><b>Fazit</b></h2><p><span>Terraform ist ein Tool für IaC mit umfangreicher Unterstützung für die Provisionierung von Cloud-Ressourcen und -Anwendungen. Die Verwendung des Keycloak Terraform Providers ist relativ einfach und ermöglicht die flexible Verwaltung von Realm-Konfigurationen, die sich gut in CI-/CD-Pipelines integrieren lässt. Damit lassen sich robuste und wartbare Realm-Konfigurationen erzeugen und verwalten.</span></p><p><span>Dieser Artikel wurde mit freundlicher Unterstützung von Thomas Darimont erstellt. In seinem </span><a href="https://github.com/thomasdarimont" target="_blank"><span>GitHub-Account</span></a> <span> sind viele Beispiele u. A. zum Thema Keycloak zu finden.</span></p><p> </p><p> </p><p><a href="https://www.codecentric.de/karriere/jobs/cloud-native-entwicklerin?utm_campaign=PeSo%20Blog%20to%20Job&utm_source=cc_blog&utm_medium=display&utm_content=cloud_native_developer_und_consultant" target="_blank"><img loading="lazy" width="660" height="220" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/8yMHLnBHR9GkaWwO9nYp" alt="Mitglieder für unsere Gilde gesucht! Jetzt der Gilde als Cloud Native Developer und Consultant (w/d/m) beitreten" /></a> </p><p> </p><p> </p>

Keycloak-Konfiguration mit Terraform

Softwareentwicklerin

<p>I have been working as a data scientist at codecentric for several years now. Thus, my language of choice is Python and I am using it in several projects on a daily basis. Last year, I got pretty excited about the announcement of the new versions of the Apple M1 chip because it offered a much higher performance. Usually, I don’t need to run long trainings of neural networks on my laptop. But for small experiments, and of course debugging, my hope was to save a lot of time. In December last year I was privileged enough to choose a new business laptop and so I took the opportunity to get a Macbook Pro 16 with M1Pro Silicon. The whole installation started smoothly until I wanted to run my Python projects. Then I ran into …</p><h2>Problems</h2><p>Apple’s M1 chip is built on the ARM architecture in contrast to x64 chips used in prior Macbook versions. On the one hand, the advantage of this is that Apple became independent from Intel so they could design their own chip. The disadvantage, on the other hand, is that all software either needs to be emulated (with Rosetta2) or recompiled with an architecture-specific compiler for arm64 (M1) instead of x86 like before … Unfortunately, a recompilation is unlikely to work out of the box and code changes must be applied. Although Python is a scripting language, this also holds true for it because the interpreter is written in C. Furthermore, a lot of major packages like Numpy and Pandas are using C/C++ extensions for getting better performance, too. In short: With <code>pip install</code> I was not able to get a running environment with all necessary packages installed. There is the alternative way of using Miniforge which is a variant of Conda. But this approach lacks the possibility of reproducible environments and therefore was not an option.</p><h2>Goal</h2><p>In a Python project with multiple people involved it is crucial that the software environment is consistent across different platforms and systems. A way to achieve this is using a package manager like Poetry (<a href="https://python-poetry.org/" target="_blank">https://python-poetry.org/</a>  ) for Python. It stores all package dependencies and their exact versions in files tracked with Git, which makes it possible to rerun the installation everywhere generating the same environment. Besides the reproducibility of the environment, another mandatory feature is the possibility to debug code in an easy way. Everyone who develops on a regular basis knows how much time it can save to investigate the variables and behavior step by step in an interactive manner. And since this  is already possible with IDEs like PyCharm or VsCode, I didn’t want to miss out on this feature when changing  to a new architecture.</p><h2>What didn’t work</h2><p>The first thing I tried was installing Miniforge and running <code>poetry install</code>, a way of installing the specified dependencies into a virtualenv. Every time a package couldn’t be installed via pip (which Poetry is using in the background), I tried to install it with <code>conda install</code>. This soon became very complicated and due to package version restrictions I abandoned this approach. The second attempt I gave a try was running the terminal in an x64 emulation with Rosetta2. The idea was to use this to install only Python x64 packages. Unfortunately, I didn’t find out how to set the compiler correctly and for me it was intransparent what compilers and which version of Homebrew was used. Thus, not seeing any way to succeed here, I searched for a different way.</p><h2>Final approach</h2><p>The final approach I tried and which led to success was using Docker and running the required environments as containers. Each container is also emulated as x64, which makes it possible to install every package as before on prior Macbooks. All commands and steps are provided in the Git repository: <a href="https://github.com/JohnDenis/py-poetry-m1" target="_blank">https://github.com/JohnDenis/py-poetry-m1</a> . For abbreviation purposes I will only use Makefile targets for the description. They will be replaced with the corresponding command in the <strong>Makefile</strong>. You find it at the end of this post or in the Github repository. Additionally, Docker-Desktop must be installed to get everything running.</p><ol><li>As a first step, you need to run a container from your desired Python base image (here 3.8) <code>make run_raw</code></li><li>Now you are in a shell of the container and can install whatever is necessary. Additionally, the project directory is mounted in the container, which allows for changes via Poetry to be stored directly in the correct <strong>pyproject.toml</strong> and <strong>poetry.lock</strong> files. For the first installation a script is provided which is triggered by <code>make install</code>.</li><li>After the initial installation, your goal is to persist the current container as an image to use it for every run of your code. Open a second terminal without stopping the container. Run <code>make commit_raw</code> in the second terminal.</li><li>Now it’s possible to use the <strong>m1-built:latest</strong> image in combination with your favorite IDE to run and debug your Python scripts. Or you can run them from plain shell by running a container with a specific command.</li></ol><p><img width="1024" height="444" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/XKBPekrCQvuyfryze0Vl" alt="Workflow of how docker images and containers are created." /></p><h2>Updating the environment</h2><p>In some projects it occurs  rarely,in others it occurs more often: the need to change packages of your environment. To save time, you don’t want to start from scratch and reinstall all packages with every change coming. This is why this solution presents a way of changing the built Docker image:</p><ol><li>Start a Docker container of <strong>m1-built:latest</strong> by running <code>make run_built</code></li><li>Interact with the Python environment as desired (e.g. <code>poetry add</code>, <code>poetry update</code>)</li><li>Open a second terminal without stopping the current container. Run make <code>commit_raw</code> in the second terminal.</li><li>Now you have a new version stored at the <strong>m1-built:latest</strong> tag.</li></ol><h2>Flexibility of the solution</h2><p>This solution does not only work for Poetry-based environments, but also for all environments where packages are installed via pip. This means, the version of your python environment can be selected in the <strong>docker-compose.yml</strong> (e.g. 3.8, 3.9, etc) and everything else can be applied via command line when connected to the container.</p><h2>Debugging with PyCharm</h2><p>With the Docker image <strong>m1-built:latest</strong> being committed, PyCharm offers a convenient way to run and debug your project scripts.</p><ol><li>Add a new interpreter (Project Settings -> Python Interpreter)</li><li>Add a <strong>Path mapping</strong> from your project root to <code>/opt/project</code></li><li>Add Run configuration for main.py file</li></ol><p>With these steps you create a run configuration which is working in the same way as normal environments.</p><p><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/k2o5j4ATSWWUWGrIqYWj" alt="python on m1 chip" width="900" height="655" /><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/Qzjc8dfKSbuaNXLdjHVS" alt="python on m1 chip docker interpreter" width="900" height="655" /> <img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/C7PWYS2cQ3SYWhxVeasK" alt="docker config" width="900" height="605" /></p><h2>Remarks on TensorFlow</h2><p>The only package where the original Pypi packages are not working is TensorFlow. The reason seems to be  that the AVX speed-up options cannot be emulated. Unfortunately, the workaround isn’t as clean as the plain solution, but currently I don’t know a different one:</p><ol><li>Follow the instructions above and create your environment in a container.</li><li>Compile or download a version of TensorFlow where the AVX instructions are deactivated.</li><li>Replace the original installations with <code>pip install /path/to/tensorflow_wheel</code>.</li><li>Go ahead and commit the container.</li></ol><h2>Outlook</h2><p>As long as not all Python packages are compatible with the Apple M1 silicon, this solution gives you a great way to run any Python environment on your Apple computer. And even if it’s possible to install all packages via pip, I would recommend sticking to this approach because it makes the software stack encapsulated and reproducible which saves a lot of time and nerves in the long run. One additional enhancement can be building the Docker image in a CI-pipeline. Thus, not every team member needs to conduct the described steps, but you can use the image from your private Pypi repository immediately.</p>

Python on an M1 chip: Running smoothly using Docker

<p>In this blog post, we want to give you an insight into the product development of <em>tactics.ai</em>. Our initial idea was a data-driven football analysis tool that applies machine learning techniques to analyze the strengths and weaknesses of opponents and predict player and team behavior. During our development process we had to shift our primary focus away from our initial idea. Here, you will read about the key learnings, our vision and the value of customer feedback.</p><h2>Matchplan</h2><p>Being football fans since our early childhood, we have followed different teams across several competitions and observed numerous changes over the years. From systemic changes such as the implementation of new technologies (most recently: VAR) to tactical trends on the field, like FC Barcelona’s “Tiki Taka” or Jürgen Klopp’s fast pace and high pressure style, football never stops changing. As experts in Data Science with focus on Machine Learning we thought about using deep-learning methods to formulate game strategies based on video of opponent tendencies and exploitable weaknesses. Furthermore, we would be able to predict strengths and weaknesses of individual players and forecast strategic and tactical orientation of the opponent. This knowledge would be substantial for both coaches and analysts.</p><p>While in basketball play-calls can be very predictable and players <a href="https://grantland.com/features/the-toronto-raptors-sportvu-cameras-nba-analytical-revolution/" target="_blank">already have implemented technological analysis</a>  into their daily game preparations, in football the data analysis and data-driven coaching has just picked up. In general, football clubs are investing more and more in digitalization, such as implementing fan portals, offering cashless payment options in stadiums or using new technologies, like GPS-tracking. Still, we found that most tools focus on the fitness performance of the individual player and do not use the required position and event data that is already collected by the DFL (Deutsche Fußball Liga). Furthermore, many clubs are still dependent on tools that require a large amount of manual input. This leads to analysts frequently working long hours and being pressed for time in between games, e.g. in times of double-fixture weeks. Having <em>tactics.ai</em> as a tool to comprehensively scout the other team in short order would provide meaningful advantages to the analysts and provide new possibilities for game preparation.<br /> This is how <em>tactics.ai</em> was born.</p><p>Our vision with <em>tactics.ai</em> is to improve the performance of football clubs by offering them in-depth game analysis and automatically draft plays and movements of their own and the opponents’ players. <em>tactics.ai</em> quantitatively analyzes and compares fine-grain movement patterns and transfers this data into valuable information. This knowledge is both quickly accessible and easy to grasp. That not only reduces the hours analysts have to spend retrieving scenes manually but also provides clubs with new competitive advantages.</p><h2>Starting XI</h2><p>The most important step at the beginning of our process was the establishment of a suitable contact network. Using a lean startup approach, where every product decision is based on customer feedback, the actual customer plays a central role. In particular, we were looking for both coaches and analysts that could tell us about their daily routines, their pain points and what features would make their work easier. If we would not be able to get in touch with either of them, the project would most certainly not be successful, because developing a product without a participating user often results in a software not meeting the requirements – therefore a software that will not be used.<br /> Another challenge was the accessibility of data. In order to provide potential customers with a demo of our application, we needed data to feed our algorithm. From our research we knew that the availability of data for the first two leagues in Germany is very good. Besides the scouting feed video of every game, the position and event data is recorded by a centralized organization and is distributed to every club of those leagues. This means we only needed to get in touch with one club.</p><p>After various attempts through company networks, friends & family and direct approaches of football clubs, we were finally able to establish professional partnerships with whom we decided to develop the product. As a result of this partnership we were legitimized to access all recorded data, besides the video footage. Namely, the position and event data streams. The position data contains the movement of all players and the ball for the whole game. Every other event, like fouls, shots on target or yellow cards are located in the event data.</p><p>Based on these two pillars – customer partnership and data accessibility – we were well equipped to move on with our product development.</p><h2>Kickoff</h2><p>To start off, we conducted several interviews with coaches and analysts to understand the behavior and needs of our users. During the interview process, we quickly learned that the features we had in mind – to predict the behavior of the opponent or automatically expose weaknesses and strengths – were already two steps ahead. We found that our users were facing other difficulties and that they needed different features than we had expected.</p><p>In the following we describe the two main challenges, one of the coach and one of the analyst.</p><p><strong>Coach:</strong> To teach football players how they should behave in specific situations it is common to show them various video snippets while the coach is giving an explanation simultaneously. To emphasize the insights some coaches are working with tactic boards where they can visualize the tactical behavior. Thus, in the case which was described to us the coach had to pause the video, go to the magnetic board which was standing a few meters away, placing the magnets symbolizing the players and ball the same way they are in the video, and finally starting to explain his points. This means a lot of time is used for unnecessary things and especially in a setting where you have to keep the concentration high to understand most of the tactical discussion.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ekUmEclETMOvQ6abyvUz"><img width="700" height="467" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/ekUmEclETMOvQ6abyvUz" alt="Shows the view between the video footage and the tactics board" /></a> </p><p><strong>Analyst:</strong> A key in game analysis is the inspection of video footage. Talking about game preparation; an analyst usually watches a couple of games of the upcoming opponent. Either he watches the whole game gaining arbitrary insights during the process or he wants to find out specific behaviors of the opponent. Concerning the latter it is often the case that he wants to watch only the scenes where he could gain insights into the criteria he is investigating. E.g. every corner kick of one team. Right now the analyst we were talking to had a two step approach. At first he was watching the whole game, simultaneously labeling every scene regarding its content. Thus, afterwards he was able to filter the scenes regarding to his needs. The task of simultaneously labeling and watching is very time consuming which means doing that automatically would have the benefit of saving time and having this information accessible for every game.</p><p>Based on these observations, we decided to start with features that would tackle the above described challenges and thereby bring immediate value to the user. If we had decided otherwise, we would have taken high risks due to several factors.</p><ol><li>We are experts in the IT industry, not of football tactics. This means, even if we would have implemented fancy AI algorithms it is unclear whether they would have created insights for the coaches or analysts right away.</li><li>From our interviews we knew that professional analysts and coaches are constantly working long hours and have time pressure in between games in case of double-fixture weeks. Hence, if we could not reduce their daily workload it seemed unlikely that they would spend much time in helping us developing advanced AI algorithms.</li><li>Every coach has more or less his own way of analyzing games. But the commonality is to find relevant scenes and showing them to the team. Thus, with an AI focused product we might have tackled only a small subset of our target group.</li></ol><p>In summary, the user experience of our application turned out to play an important role in our product development. If we are able to provide the customer with an extraordinary user experience that is easy to grasp and fast to master, in order to optimize current workflows, we could substitute the existing tools and become their main video analyzing tool. From there, we would get even more customer feedback and could further develop our product towards our original vision.</p><h2>Halftime analysis</h2><p>Today, our tactical assistant <em>tactics.ai</em> is a tool that already solves the previous named problems of analysts and coaches. It automatically labels scenes, allows you to filter scenes for specific use cases, lets you create and manage playlists with relevant scenes, integrates a visual tactic board next to the real video footage, and thus enables the coach to directly instruct the team.</p><p>With this in mind the greatest challenge has been to take a step back from our vision and have a look at the broader picture. You don’t want to build a product which you yourself like, but a product which is liked and used by your target customer group. Thus, we implemented a customer driven development and in our opinion this is the key that determines how likely your product is to become a success or a failure.</p>

Why user-oriented development is so important – the story of tactics.ai

<p>Although everyone has an intuitive way of understanding what AI means, the term is somehow difficult to grasp in its whole complexity.<br /> One example of a definition is given by <a href="https://www.sciencedirect.com/science/article/pii/S0007681318301393" target="_blank">Kaplan, A. and M. Haenlein </a> (2019), who characterize AI as “a system’s ability to correctly interpret external data, to learn from such data, and to use those learnings to achieve specific goals and tasks through flexible adaptation.”</p><p>These days, one question arises: is there an objective way to measure the capabilities of an intelligent machine?  Or: is it even possible to draw a line between AI systems and standard computer systems?</p><h2>One of the first attempts: the Turing Test</h2><p>One of the first attempts to answer these questions was done by <a href="https://en.wikipedia.org/wiki/Alan_Turing" target="_blank">Alan Turing</a> , a famous mathematician and cryptologist during World War II.<br /> In 1950, he designed an experiment called Turing Test, where an interrogator is chatting with two other clients.</p><p>Client A is controlled by a computer program, whereas client B is a human. The task of the interrogator is now to determine only from the answers received and chat behavior of the clients which one is which.<br /> If he is not able to distinguish them reliably, the computer program passes the Turing Test successfully and is then considered AI.</p><p>The assumption of Alan Turing for this test was that only a machine with human-like intelligence could fool a human in this complex task.</p><h2>Since its creation …</h2><p>Since its creation, the test has become the most popular way in determining intelligent behavior in machines.<br /> Nevertheless, scientists question the model in its sufficiency to measure real intelligence and argue about the reliability of certain programs passing this test.</p><p>A discussion like this came up when Google presented the Google Assistant in 2018. Recordings were shown where the digital assistant <a href="https://www.youtube.com/watch?v=JvbHu_bVa_g" target="_blank">made phone calls</a> , for example, to schedule appointments at the salon or a restaurant for their clients.<br /> Compared to other digital assistants like Siri or Alexa, the new Google Assistant had a much greater capability of interacting and understanding difficult nuances in human speech. To everyone’s surprise, in the examples above, the Google Assistant would not even be recognized as a „false conversationalist“ by the interlocutors answering the phone.<br /> This indicates a success for the machine regarding the conditions of the Turing Test.</p><h2>So what is to criticize?</h2><p>So what is to criticize? Although the presentation by Google was very impressive, the outcome is not verified by the original Turing Test design. This is because the interlocutor of the phone call would take the role of the interrogator for the Turing Test, but they are not aware of this status at the time of the phone call. Therefore, they would not pay attention to indications for whether or not the caller might be a machine.<br /> It is unlikely for the receptionists to expect a computer program to call during their busy working time. They can easily miss or ignore things such as robotic voice patterns, anomalies in the sound, or unusual pauses in the conversation.</p><h2>In the future …</h2><p>In the future of determining AI, the Turing Test may hold great possibilities of measuring general intelligence, especially in interaction. However, these days, the scientific community focuses more on objective ways to measure AI in very specific settings, such as computer vision tasks, voice recognition and so forth.</p><p>Personally, I don’t consider the development of real, complex human-like intelligent machines possible in the upcoming years. The current techniques are just too restricted to their area of design. Alan Turing predicted machines to pass his test with certainty by the year 2000, but time proved him wrong and we are still waiting for this event to happen.</p>

How to define AI? – Using the Turing Test to measure human-like intelligence in machines

In this article, we'll explore how to use the Poetry package manager to manage the dependencies of a machine learning project that makes use of the M1 GPU for TensorFlow training. We'll cover the motivation for using Poetry in this context, and we'll provide a solution that makes use of Poetry's extras feature to manage the project's dependencies in a consistent and reproducible way.

## Motivation

There are several reasons why using Poetry to manage the dependencies of a machine learning project that uses the M1 GPU for TensorFlow training can be advantageous. First, Poetry makes it easy to manage the Python software environment in a consistent way across different platforms and systems. This is especially important in larger projects, where reproducibility and consistency are critical.
Secondly, using the M1 GPU for TensorFlow training requires the installation of different Python packages than those required for x64/x86 systems. Manually managing these dependencies can be tedious and error-prone, especially in a CI/CD pipeline where the software environment needs to be reproduced consistently.
Finally, using only Pip or Conda as a software manager may not be sufficient for projects that require the consistent reproduction of the software environment. In these cases, Poetry can provide a more robust and flexible solution.

## Solution

To manage the dependencies of a machine learning project that uses the M1 GPU for tensorflow training, we can make use of Poetry's extras feature. This allows us to specify optional dependencies for our project, which can be installed using the --extras flag when running poetry install.
First, we'll create an optional extra called m1 that includes the necessary packages for using the M1 GPU for TensorFlow training. This extra can be specified in the pyproject.toml file like this:

```toml
[tool.poetry.extras]
tensorflow-m1 =["tensorflow-macos==2.9.2", "tensorflow-metal==0.5.0"]
```

Next, we can create an optional extra for x64/x86 systems, which includes the necessary packages for that platform. This extra can be specified in the same `pyproject.toml` file like this:

```toml
[tool.poetry.extras]
tensorflow-x64 = ["tensorflow==2.9.2"]
```

Now, when installing our project on an M1 system, we can use the *--extras/ -E* flag to tell Poetry to also install the `tensorflow-m1` extra:

```bash
poetry install -E tensorflow-m1
```

Similarly, when installing our project on an x64/x86 system, we can use the *--extras/ -E*  flag to tell Poetry to also install the `tensorflow-x64` extra:

```bash
poetry install -E tensorflow-x64
```

This allows us to manage our project's dependencies in a way that is consistent across different platforms.
Finally, after Poetry install has finished installing our project's dependencies, we can use Conda to install any additional packages that require compiled binaries. This allows us to manage our project's dependencies in a way that is both consistent and flexible.
 
## Recommendation

If you're considering using the M1 GPU for TensorFlow training, we highly recommend making use of it. The M1 GPU is a lot faster in calculations with TensorFlow than a CPU, which can significantly accelerate the training process. By using the M1 GPU, you can potentially reduce the time it takes to train your machine learning models by an order of magnitude or more, making it an extremely valuable resource for any machine learning project.

In summary, the M1 GPU is a powerful hardware for TensorFlow training that can greatly accelerate the process of training machine learning models. By making use of Poetry and its extras feature, you can manage the dependencies of your project in a consistent and reproducible way, ensuring that your machine learning project is both reliable and efficient.
 
You can find an example in
<a href="https://github.com/dstalzjohn/py-poetry-m1" target="_blank"> this repository</a>.

How to combine Poetry, TensorFlow, and the power of the Apple M1 GPU

Machine Learning Specialist

IAM & IT Consultant, Software Engineer

Fullstack Developer & Azure Cloud Engineer

Rust in der Cloud: Performance-Vergleich mit TypeScript und Java in AWS-Lambda

IT Developer & Consultant 

Werkstudent

Junior IT-Consultant

Head of Industrial Solutions

Team assistance

Business Solutions Consultant

Junior IT Consultant

Atlassian Consultant

Personalentwickler

<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://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/sOvVWDgxTkjdHl0SgVR9" alt="Beginn des Trainings" /><img loading="lazy" width="200" height="200" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/VBcx4FbTR66jP8zWwi5L" alt="Nach 200 gespielten Spielen" /><br /> <img loading="lazy" width="200" height="200" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/XvrD3ETtQ4u73y05pOhM" alt="Nach 400 gespielten Spielen" /><img loading="lazy" width="200" height="200" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/U5o6PoiTQCoDEep0RZXU" alt="Nach 3000 gespielten Spielen" /><figcaption>Spätestens seit <em>Rocky</em> wissen wir, dass ein Training nur mit eineer Trainings-Montage gut ist.</figcaption></figure><p>Die Schlange lernt tatsächlich dazu! Innerhalb weniger Minuten läuft sie zielstrebig auf das Futter zu und weicht Wänden aus — allerdings fängt sie sich gerne selbst. Für unsere Zwecke soll dieses Verhalten aber vorerst ausreichen.</p><h2>Modell in Java laden</h2><p>Um den Kreis zu schließen, laden wir unser trainiertes Modell mit <em>deeplearning4j</em> in Java …</p><div>

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

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

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

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

Wie man Java-Klassen in Python benutzt

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

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

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

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

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

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

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

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

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

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

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

How to use Java classes in Python

Münster | Team

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

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

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

Zu deiner Suche haben wir leider keine passenden Blogartikel gefunden. 

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

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

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

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

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

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

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

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

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

Job application form field placeholder 10

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

Job application form field placeholder 11

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

Willkommen im Team Münster

Jetzt für unseren Newsletter anmelden