Heute feiern wir den jährlichen Christopher Street Day – das europäische Äquivalent zu Gay Pride oder Pride Parades, um für die Rechte von LGBTQIA+ Menschen und gegen Diskriminierung und Ausgrenzung zu kämpfen.

Seit 1969, als die erste Demonstration auf der Christopher Street in New York City stattfand, haben wir bereits viele Fortschritte gemacht: Heute ist die gleichgeschlechtliche Ehe in 30 Ländern rechtlich vollzogen und anerkannt, und das „unbestimmte“ Geschlecht ist in 20 Ländern rechtlich anerkannt.

Allerdings steht Homosexualität in vielen Ländern immer noch unter Strafe und selbst in fortschrittlicheren Ländern kommt es immer noch zu Gewalt gegen queere Menschen. Trotz der bereits erzielten Fortschritte ist es also noch ein weiter Weg bis zur Gleichstellung queerer Menschen. Der Christopher Street Day hat also nach wie vor seine Berechtigung: Als Protest gegen Ungerechtigkeit und als Zeichen für eine bunte, vielfältige und tolerante Gesellschaft.

Vorurteile in der KI – Ein sehr reales Problem

In den letzten Jahren haben die Themen Diskriminierung und Vorurteile noch an Relevanz gewonnen, denn mit der Digitalisierung schleichen sich diese Vorurteile auch in die Schlüsseltechnologie unserer Zukunft ein: Künstliche Intelligenz. Intelligente Computersysteme, die aus Daten lernen und unsere Gesellschaft verändern werden, wie wir es noch nie erlebt haben. Es ist von entscheidender Bedeutung, dass sie mit unterschiedlichen Datensätzen und unter Mitwirkung einer Vielzahl von Entwickler:innen programmiert werden. Andernfalls besteht die Gefahr, dass sie voreingenommene und diskriminierende KI-Systeme entwickeln.

Die Kontroverse um die Veröffentlichung von Googles Chatbot „Allo“ ist ein Paradebeispiel für diese potenzielle Falle. Google veröffentlichte Allo, seine neue Messaging-App, im Jahr 2016 mit großem Tamtam. Die App enthielt einen Chatbot namens „Smart Reply“, der auf der Grundlage früherer Interaktionen Antworten auf Nachrichten vorschlägt. Es stellte sich jedoch schnell heraus, dass der Bot gegenüber Frauen voreingenommen war und dazu neigte, abfällige und sexuell eindeutige Antworten auf Nachrichten von Nutzerinnen vorzuschlagen. Dieser Vorfall unterstreicht die Notwendigkeit für Unternehmen, bei der Entwicklung von KI stärker auf die potenziellen Risiken von Voreingenommenheit zu achten. Diversität muss in jeder Phase des Prozesses berücksichtigt werden, von der Datenerfassung über die Entwicklung von Algorithmen bis hin zu Nutzertests.

In der Tat gab es viele weitere Vorfälle von KI-Diskriminierung gegenüber Frauen und People of Color, wie z. B. Amazons Rekrutierungstool, das systematisch männliche Bewerber bevorzugte, oder Facebooks Kennzeichnungssystem für Bilder, das einen dunkelhäutigen Mann fälschlicherweise als Primaten identifizierte. Aber nicht nur Frauen und People of Color leiden unter Vorurteilen in der KI, auch die queere Community ist davon betroffen.

Case Study: DALL-E 2

Werfen wir dazu einen Blick auf DALL-E 2, das von OpenAI entwickelt wurde. Es ist eine der neuesten und bahnbrechendsten KI-Technologien, die es gibt. DALL-E 2 ist eine KI, die auf der Grundlage von Textbeschreibungen realistische Bilder und Kunstwerke erzeugt.

Um zu prüfen, wie voreingenommen oder gleichberechtigt diese KI-Lösung gegenüber queeren Menschen ist, habe ich DALL-E 2 angewiesen, Bilder auf der Grundlage des Eingabetextes „ein glückliches Paar“ mit verschiedenen Kunststilanweisungen (z. B. Ölgemälde oder digitale Kunst) zu erzeugen.

Wenn Ihr Euch die Ergebnisse anseht, seht Ihr, dass nur Bilder von heterosexuellen Paaren erzeugt wurden. Auch die Bilder, die auf dem Text „eine glückliche Familie“ basieren, unterscheiden sich in dieser Hinsicht nicht – es sind keine gleichgeschlechtlichen Eltern auf den Bildern zu sehen.

Um also ein Bild eines homosexuellen Paares zu erhalten, versuche ich, dem KI-Modell eine spezifischere Beschreibung zu geben: „ein glückliches queeres Paar“. Wie Ihr sehen könnt, hat DALL-E 2 schließlich einige Bilder von gleichgeschlechtlichen Paaren erzeugt. Aber auch hier scheint das System voreingenommen zu sein – es wurde kein einziges Bild eines lesbischen Paares erzeugt.

Die Ursachen der Diskriminierung bei Technologien wie DALL-E 2

Haben wir jetzt also die Bestätigung, dass KI homophob ist? Nicht so ganz. Es geht hier nicht um Homophobie oder Sexismus auf Seiten von DALL-E oder GPT-3. Diese Systeme reproduzieren die Strukturen und Hierarchien unserer Gesellschaft. Sie wiederholen nur, was sie in der Vergangenheit gelernt haben. Wenn wir diese Vorurteile ändern und Chancengleichheit schaffen wollen, müssen wir diese Systeme auf eine integrative Weise trainieren.

Warum genau sind KI-Systeme wie DALL-E 2 also voreingenommen und was können wir dagegen tun? Die Antwort auf diese Frage besteht aus drei Teilen:

  • den Daten,
  • dem Ziel,
  • und den Entwickler:innen.

#1 Daten

Erstens: KI-Systeme lernen nur das, was in den Daten enthalten ist. Wenn die Trainingsdaten verzerrt sind, ist auch die KI verzerrt. DALL-E 2 wurde mit Tausenden von Online-Bildbeschreibungspaaren aus dem Internet trainiert. Aufgrund historischer, sozialer und ethnischer Gegebenheiten, gibt es viel mehr heterosexuelle Paarbilder mit der Beschreibung „ein glückliches Paar“ als homosexuelle Paarbilder im Internet. DALL-E 2 hat also herausgefunden, dass die Beschreibung „ein glückliches Paar“ mit größerer Wahrscheinlichkeit mit heterosexuellen Paaren auf einem Bild assoziiert wird.

#2 Ziel

Zweitens: Damit ein KI-Algorithmus wie DALL-E 2 aus Daten lernen kann, braucht er ein Ziel zur Optimierung, eine Definition von Erfolg und Misserfolg. Genauso wie Ihr in der Schule gelernt habt, indem Ihr Eure Noten optimiert habt. Eure Noten haben Euch gezeigt, ob Ihr erfolgreich wart oder nicht, und was Ihr noch lernen müsst oder nicht.

In ähnlicher Weise lernt auch der Algorithmus, indem er sich die Daten ansieht und herausfindet, was mit Erfolg verbunden ist. Welche Situation führt zum Erfolg? Wenn wir also eine unvoreingenommene und faire künstliche Intelligenz schaffen wollen, müssen wir auch darüber nachdenken, welche Zielsetzung wir ihr geben. Wir müssen ihr sagen, dass sie sich vor Voreingenommenheit, Vorurteilen und Diskriminierung in Acht nehmen muss. Für DALL-E 2 könnte man zum Beispiel eine bestimmte Diversitätskennzahl in die Leistungsbewertungskriterien aufnehmen.

#3 Entwickler:innen

Drittens ist es die Entwickler:innengemeinschaft, die direkt oder indirekt, bewusst oder unbewusst ihre eigenen Vorurteile in die KI-Technologie einbringt. Sie wählen die Daten aus, sie definieren das Optimierungsziel und sie gestalten die Nutzung von KI. Meistens bringen sie ihre Voreingenommenheit nicht aktiv in diese Systeme ein. Wir alle leiden jedoch unter Vorurteilen, derer wir uns nicht bewusst sind. Diese Voreingenommenheit ist ein Versuch unseres Gehirns, die unglaublich komplexe Welt um uns herum zu vereinfachen. Die derzeitige Gemeinschaft der KI-Entwickler:innen besteht zu über 80 % aus weißen Cis-Männern. KI wird von einer sehr homogenen Gruppe entworfen, entwickelt und bewertet. Die Werte, Ideen und Vorurteile, die sich in KI-Systeme einschleichen, sind daher buchstäblich engstirnig.

Mögliche Lösungen für das Problem

Der entscheidende Schritt zu einer gerechteren und unvoreingenommeneren KI ist also eine vielfältige und integrative KI-Entwicklungsgemeinschaft. Unterschiedliche Menschen können die blinden Flecken und Vorurteile der anderen besser überprüfen.

Wenn wir über unsere eigenen Vorurteile nachdenken und gemeinsam daran arbeiten, die Vergangenheit nicht nur zu extrapolieren, sondern vorsichtig und kritisch aus ihr zu lernen, können wir die Welt zu einem viel vielfältigeren, integrativeren und gleichberechtigteren Ort machen. Nur dann können wir hoffen, KI-Technologien zu entwickeln, die wirklich inklusiv und fair sind.

Unsere Bemühungen um Diversität in der Entwicklung und am Arbeitsplatz

Wir bei statworx versuchen auch unser Bestes, um uns weiterzubilden und unseren Horizont zu erweitern. Wir engagieren uns aktiv für die Aufklärung der Gesellschaft im Bezug auf künstliche Intelligenz, z.B. in unserer Initiative AI & Society. Erst kürzlich habe ich im Namen der Initaitive zum Thema „Vorurteile in KI abbauen“ einen Blogartikel veröffentlicht und bei der Konferenz „Unfold“ in Bern einen Vortrag dazu gehalten.

Darüber hinaus haben wir uns entschlossen, die Charta der Vielfalt zu unterzeichnen. Die Charta der Vielfalt ist eine Arbeitgebendeninitiative zur Förderung von Vielfalt in Unternehmen und Institutionen. Ziel der Initiative ist es, die Anerkennung, Wertschätzung und Einbeziehung von Vielfalt in der Arbeitswelt in Deutschland voranzubringen. Für uns bei statworx ist dies ein Weg, um unseren Werten als Unternehmen gerecht zu werden, die auf Vielfalt, Inklusivität und Teamarbeit beruhen.

FYI: 20% dieses Artikels wurden vom KI Text Generator von neuroflash geschrieben. Livia Eichenberger Livia Eichenberger Livia Eichenberger Livia Eichenberger Livia Eichenberger

In den letzten drei Beiträgen dieser Serie haben wir erklärt, wie man ein Deep-Learning-Modell trainiert, um ein Auto anhand seiner Marke und seines Modells zu klassifizieren, basierend auf einem Bild des Autos (Teil 1), wie man dieses Modell aus einem Docker-Container mit TensorFlow Serving einsetzt (Teil 2) und wie man die Vorhersagen des Modells erklärt (Teil 3). In diesem Beitrag lernt ihr, wie ihr mit Dash eine ansprechende Oberfläche um unseren Auto-Modell-Classifier herum bauen könnt.

Wir werden unsere Machine Learning-Vorhersagen und -Erklärungen in ein lustiges und spannendes Spiel verwandeln. Wir präsentieren den Anwender*innen zunächst ein Bild von einem Auto. Die Anwender*innen müssen erraten, um welches Automodell und welche Marke es sich handelt – das Machine-Learning-Modell wird das Gleiche tun. Nach 5 Runden wird ausgewertet, wer die Automarke besser vorhersagen kann: die Anwender*innen oder das Modell.

Das Tech Stack: Was ist Dash?

Dash ist, wie der Name schon sagt, eine Software zum Erstellen von Dashboards in Python. In Python, fragen ihr euch? Ja – ihr müsst nichts direkt in HTML oder Javascript programmieren (obwohl ein grundlegendes Verständnis von HTML sicherlich hilfreich ist). Eine hervorragende Einführung findet ihr in dem ausgezeichneten Blogpost meines Kollegen Alexander Blaufuss.

Um das Layout und Styling unserer Web-App zu vereinfachen, verwenden wir auch Dash Bootstrap Components. Sie folgen weitgehend der gleichen Syntax wie die standardmäßigen Dash-Komponenten und fügen sich nahtlos in das Dash-Erlebnis ein.

Denkt daran, dass Dash für Dashboards gemacht ist – das heißt, es ist für Interaktivität gemacht, aber nicht unbedingt für Apps mit mehreren Seiten. Mit dieser Info im Hinterkopf werden wir in diesem Artikel Dash an seine Grenzen bringen.

Organisation ist alles – Die Projektstruktur

Um alles nachbauen zu können, solltet ihr euch unser GitHub-Repository ansehen, auf dem alle Dateien verfügbar sind. Außerdem könnt ihr alle Docker-Container mit einem Klick starten und loslegen.

Die Dateien für das Frontend selbst sind logischerweise in mehrere Teile aufgeteilt. Es ist zwar möglich, alles in eine Datei zu schreiben, aber man verliert leicht den Überblick und daher später schwer zu pflegen. Die Dateien folgen der Struktur des Artikels:

  1. In einer Datei wird das gesamte Layout definiert. Jeder Button, jede Überschrift, jeder Text wird dort gesetzt.
  2. In einer anderen Datei wird die gesamte Dashboard-Logik (sogenannte Callbacks) definiert. Dort wird z. B. definiert, was passieren soll, nachdem die Benutzer*innen auf eine Schaltfläche geklickt hat.
  3. Wir brauchen ein Modul, das 5 zufällige Bilder auswählt und die Kommunikation mit der Prediction and Explainable API übernimmt.
  4. Abschließend gibt es noch zwei Dateien, die die Haupteinstiegspunkte (Entry Points) zum Starten der App sind.

Erstellen der Einstiegspunkte – Das große Ganze

Beginnen wir mit dem letzten Teil, dem Haupteinstiegspunkt für unser Dashboard. Wenn ihr wisst, wie man eine Web-App schreibt, wie z. B. eine Dash-Anwendung oder auch eine Flask-App, ist euch das Konzept einer App-Instanz vertraut. Vereinfacht ausgedrückt, ist die App-Instanz alles. Sie enthält die Konfiguration für die App und schließlich das gesamte Layout. In unserem Fall initialisieren wir die App-Instanz direkt mit den Bootstrap-CSS-Dateien, um das Styling überschaubarer zu machen. Im gleichen Schritt exponieren wir die zugrundeliegende Flask-App. Die Flask-App wird verwendet, um das Frontend in einer produktiven Umgebung zu bedienen.

# app.py
import dash
import dash_bootstrap_components as dbc

# ...

# Initialize Dash App with Bootstrap CSS
app = dash.Dash(
    __name__,
    external_stylesheets=[dbc.themes.BOOTSTRAP],
)

# Underlying Flask App for productive deployment
server = app.server

Diese Einstellung wird für jede Dash-Anwendung verwendet. Im Gegensatz zu einem Dashboard benötigen wir eine Möglichkeit, mit mehreren URL-Pfaden umzugehen. Genauer gesagt, wenn die Benutzer*innen /attempt eingibt, wollen wir ihm erlauben, ein Auto zu erraten; wenn er /result eingibt, wollen wir das Ergebnis seiner Vorhersage anzeigen.

Zunächst definieren wir das Layout. Bemerkenswert ist, dass es zunächst grundsätzlich leer ist. Ihr findet dort eine spezielle Dash Core Component. Diese Komponente dient dazu, die aktuelle URL dort zu speichern und funktioniert in beide Richtungen. Mit einem Callback können wir den Inhalt auslesen, herausfinden, welche Seite die Benutzer*innen aufrufen möchte, und das Layout entsprechend rendern. Wir können auch den Inhalt dieser Komponente manipulieren, was praktisch eine Weiterleitung auf eine andere Seite ist. Das leere div wird als Platzhalter für das eigentliche Layout verwendet.

# launch_dashboard.py
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
from app import app

# ...

# Set Layout
app.layout = dbc.Container(
    [dcc.Location(id='url', refresh=False),
     html.Div(id='main-page')])

Die Magie geschieht in der folgenden Funktion. Die Funktion selbst hat ein Argument, den aktuellen Pfad als String. Basierend auf dieser Eingabe gibt sie das richtige Layout zurück. Wenn die Benutzer*innen zum Beispiel zum ersten Mal auf die Seite zugreift, ist der Pfad / und das Layout daher start_page. Auf das Layout werden wir gleich noch im Detail eingehen; beachtet zunächst, dass wir an jedes Layout immer eine Instanz der App selbst und den aktuellen Spielzustand übergeben.

Damit diese Funktion tatsächlich funktioniert, müssen wir sie mit dem Callback Decorator schmücken. Jeder Callback benötigt mindestens eine Eingabe und mindestens eine Ausgabe. Eine Änderung des Inputs löst die Funktion aus. Der Eingang ist einfach die oben definierte Ortskomponente mit der Eigenschaft Pathname. Einfach ausgedrückt, aus welchem Grund auch immer sich der Pfad ändert, wird diese Funktion ausgelöst. Die Ausgabe ist das neue Layout, gerendert in dem zuvor zunächst leeren div.

# launch_dashboard.py
import dash_html_components as html
from dash.dependencies import Input, Output
from dash.exceptions import PreventUpdate

# ...

@app.callback(Output('main-page', 'children'), [Input('url', 'pathname')])
def display_page(pathname: str) -> html:
    """Function to define the routing. Mapping routes to layout.

    Arguments:
        pathname {str} -- pathname from url/browser

    Raises:
        PreventUpdate: Unknown/Invalid route, do nothing

    Returns:
        html -- layout
    """
    if pathname == '/attempt':
        return main_layout(app, game_data, attempt(app, game_data))

    elif pathname == '/result':
        return main_layout(app, game_data, result(app, game_data))

    elif pathname == '/finish':
        return main_layout(app, game_data, finish_page(app, game_data))

    elif pathname == '/':
        return main_layout(app, game_data, start_page(app, game_data))

    else:
        raise PreventUpdate

Layout – Schön & Shiny

Beginnen wir mit dem Layout unserer App – wie soll sie aussehen? Wir haben uns für ein relativ einfaches Aussehen entschieden. Wie ihr in der Animation oben sehen könnt, besteht die App aus drei Teilen: dem Header, dem Hauptcontent und dem Footer. Der Header und der Footer sind auf jeder Seite gleich, nur der Hauptinhalt ändert sich. Einige Layouts aus dem Hauptcontent sind in der Regel eher schwierig zu erstellen. Zum Beispiel besteht die Ergebnisseite aus vier Boxen. Die Boxen sollten immer die gleiche Breite von genau der Hälfte der verwendeten Bildschirmgröße haben, können aber je nach Bildgröße in der Höhe variieren. Sie dürfen sich aber nicht überlappen, usw. Von den Cross-Browser-Inkompatibilitäten ganz zu schweigen.

Ihr könnt euch sicher vorstellen, dass wir leicht mehrere Arbeitstage damit hätten verbringen können, das optimale Layout zu finden. Glücklicherweise können wir uns wieder einmal auf Bootstrap und das Bootstrap Grid System verlassen. Die Hauptidee ist, dass ihr so viele Zeilen wie ihr wollt (zwei, im Fall der Ergebnisseite) und bis zu 12 Spalten pro Zeile (ebenfalls zwei für die Ergebnisseite) erstellen könnt. Die Begrenzung auf 12 Spalten basiert auf der Tatsache, dass Bootstrap die Seite intern in 12 gleich große Spalten aufteilt. Ihr müsst nur mit einer einfachen CSS-Klasse definieren, wie groß die Spalte sein soll. Und was noch viel cooler ist: Ihr könnt mehrere Layouts einstellen, je nach Bildschirmgröße. Es wäre also nicht schwierig, unsere App vollständig responsive zu machen.

Um auf den Dash-Teil zurückzukommen, bauen wir eine Funktion für jedes unabhängige Layout-Teil. Den Header, den Footer und eine für jede URL, die die Benutzer*innen aufrufen könnte. Für den Header sieht das so aus:

# layout.py
import dash_bootstrap_components as dbc
import dash_html_components as html

# ...

def get_header(app: dash.Dash, data: GameData) -> html:
    """Layout for the header

    Arguments:
        app {dash.Dash} -- dash app instance
        data {GameData} -- game data

    Returns:
        html -- html layout
    """
    logo = app.get_asset_url("logo.png")

    score_user, score_ai = count_score(data)

    header = dbc.Container(
        dbc.Navbar(
            [
                html.A(
                    # Use row and col to control vertical alignment of logo / brand
                    dbc.Row(
                        [
                            dbc.Col(html.Img(src=logo, height="40px")),
                            dbc.Col(
                                dbc.NavbarBrand("Beat the AI - Car Edition",
                                                className="ml-2")),
                        ],
                        align="center",
                        no_gutters=True,
                    ),
                    href="/",
                ),
                # You find the score counter here; Left out for clarity
            ],
            color=COLOR_STATWORX,
            dark=True,
        ),
        className='mb-4 mt-4 navbar-custom')

    return header

Auch hier seht ihr, dass wir die App-Instanz und den globalen Spieldatenstatus an die Layout-Funktion übergeben. In einer perfekten Welt müssten wir mit keiner dieser Variablen im Layout herumspielen. Leider ist das eine der Einschränkungen von Dash. Eine perfekte Trennung von Layout und Logik ist nicht möglich. Die App-Instanz wird benötigt, um dem Webserver mitzuteilen, dass er das STATWORX-Logo als statische Datei ausliefern soll.

Natürlich könnte man das Logo von einem externen Server ausliefern, das machen wir ja auch für die Fahrzeugbilder, aber nur für ein Logo wäre das ein bisschen zu viel des Guten. Für die Spieldaten müssen wir den aktuellen Punktestand des Benutzers und der KI berechnen. Alles andere ist entweder normales HTML oder Bootstrap-Komponenten. Wer sich damit nicht auskennt, den kann ich noch einmal auf den Blogpost von meinem Kollegen Alexander verweisen oder auf eines der zahlreichen HTML-Tutorials im Internet.

Callbacks – Reaktivität einführen

Wie bereits erwähnt, sind Callbacks das Mittel der Wahl, um das Layout interaktiv zu gestalten. In unserem Fall bestehen sie hauptsächlich aus der Handhabung des Dropdowns sowie der Button Klicks. Während die Dropdowns relativ einfach zu programmieren waren, bereiteten uns die Buttons einige Kopfschmerzen.

Einem guten Programmierstandard folgend, sollte jede Funktion genau eine Verantwortung haben. Deshalb haben wir für jeden Button einen Callback eingerichtet. Nach einer Art Eingabevalidierung und Datenmanipulation ist das Ziel, die Benutzer*innen auf die folgende Seite umzuleiten. Während die Eingabe für den Callback das Button-Klick-Ereignis und möglicherweise einige andere Eingabeformulare ist, ist die Ausgabe immer die Location-Komponente, um die Benutzer*innen weiterzuleiten. Leider erlaubt Dash nicht, mehr als einen Callback zum gleichen Ausgang zu haben. Daher waren wir gezwungen, die Logik für jede Schaltfläche in eine Funktion zu quetschen.

Da wir die Benutzereingaben auf der Versuchsseite validieren mussten, haben wir die aktuellen Werte aus dem Dropdown an den Callback übergeben. Während das für die Versuchsseite einwandfrei funktionierte, funktionierte die Schaltfläche auf der Ergebnisseite nicht mehr, da keine Dropdowns zur Übergabe an die Funktion verfügbar waren. Wir mussten ein verstecktes, nicht funktionierendes Dummy-Dropdown in die Ergebnisseite einfügen, damit die Schaltfläche wieder funktionierte. Das ist zwar eine Lösung und funktioniert in unserem Fall einwandfrei, aber für eine umfangreichere Anwendung könnte es zu kompliziert sein.

Data Download – Wir brauchen Autos

Jetzt haben wir eine schöne App mit funktionierenden Buttons und so weiter, aber die Daten fehlen noch. Wir müssen Bilder, Vorhersagen und Erklärungen in die App einbinden.

Die High-Level-Idee ist, dass jede Komponente für sich alleine läuft – zum Beispiel in einem eigenen Docker-Container mit eigenem Webserver. Alles ist nur lose über APIs miteinander gekoppelt. Der Ablauf ist der folgende:

  • Schritt 1: Abfrage einer Liste aller verfügbaren Auto-Images. Wähle zufällig 5 aus und fordere diese Bilder vom Webserver an.
  • Schritt 2: Sende für alle 5 Bilder eine Anfrage an die Vorhersage-API und parse das Ergebnis aus der API.
  • Schritt 3: Sende wiederum für alle 5 Bilder eine Anfrage an die Explainable-API und speichere das zurückgegebene Bild.

Kombiniert nun jede Ausgabe in der GameData-Klasse.

Aktuell speichern wir die GameData-Instanz als globale Variable. Das erlaubt uns, von überall darauf zuzugreifen. Das ist zwar theoretisch eine schlaue Idee, funktioniert aber nicht, wenn mehr als eine Benutzerin versucht, auf die App zuzugreifen. Derdie zweite Benutzerin wird den Spielstatus vom ersten sehen. Da wir planen, das Spiel auf Messen auf einer großen Leinwand zu zeigen, ist das für den Moment in Ordnung. In Zukunft könnten wir das Dashboard mit Shiny Proxy starten, so dass jeder Benutzer seinen eigenen Docker-Container mit einem isolierten globalen Status erhält.

Data Storage – Die Autos parken

Die native Dash-Methode besteht darin, benutzerspezifische Zustände in einer Store-Komponente zu speichern. Das ist im Grunde dasselbe wie die oben erläuterte Location-Komponente. Die Daten werden im Webbrowser gespeichert, ein Callback wird ausgelöst, und die Daten werden an den Server gesendet. Der erste Nachteil ist, dass wir bei jedem Seitenwechsel die gesamte Spieldateninstanz vom Browser zum Server übertragen müssen. Das kann ziemlich viel Traffic verursachen und verlangsamt das gesamte App-Erlebnis.

Außerdem müssen wir, wenn wir den Spielzustand ändern wollen, dies über einen Callback tun. Die Beschränkung auf einen Callback pro Ausgabe gilt auch hier. Unserer Meinung nach macht es nicht allzu viel aus, wenn Sie ein klassisches Dashboard haben; dafür ist Dash gedacht. Die Verantwortlichkeiten sind getrennt. In unserem Fall wird der Spielstatus von mehreren Komponenten aus aufgerufen und verändert. Wir haben Dash definitiv an seine Grenzen gebracht.

Eine weitere Sache, die ihr im Auge behalten solltet, wenn ihr euch entscheidet, eure eigene Microservice-App zu bauen, ist die Performance der API-Aufrufe. Anfänglich haben wir die berühmte requests Bibliothek verwendet. Während wir große Fans dieser Bibliothek sind, sind alle Anfragen blockierend. Daher wird die zweite Anfrage ausgeführt, sobald die erste abgeschlossen ist. Da unsere Anfragen relativ langsam sind (bedenkt, dass im Hintergrund vollwertige neuronale Netze laufen), verbringt die App viel Zeit mit Warten. Wir haben asynchrone Aufrufe mit Hilfe der Bibliothek aiohttp implementiert. Alle Anfragen werden nun parallel verschickt. Die App verbringt weniger Zeit mit Warten, und der Benutzer ist früher bereit zum Spielen.

Fazit und Hinweise

Auch wenn die Web-App einwandfrei funktioniert, gibt es ein paar Dinge, die zu beachten sind. Wir haben Dash verwendet, wohl wissend, dass es als Dashboarding-Tool gedacht ist. Wir haben es bis an die Grenzen und darüber hinaus getrieben, was zu einigen suboptimalen interessanten Design-Entscheidungen führte.

Zum Beispiel könnt ihr nur einen Callback pro Ausgabeparameter setzen. Mehrere Callbacks für dieselbe Ausgabe sind derzeit nicht möglich. Da das Routing von einer Seite zur anderen im Wesentlichen eine Änderung des Ausgabeparameters (‚url‘, ‚pathname‘) ist, muss jeder Seitenwechsel durch einen Callback geleitet werden. Das erhöht die Komplexität des Codes exponentiell.

Ein weiteres Problem ist die Schwierigkeit, Zustände über mehrere Seiten hinweg zu speichern. Dash bietet mit der Store Component die Möglichkeit, Benutzerdaten im Frontend zu speichern. Das ist eine hervorragende Lösung für kleine Apps; bei größeren steht man schnell vor dem gleichen Problem wie oben – ein Callback, eine Funktion zum Schreiben in den Store, reicht einfach nicht aus. Entweder ihr nutzt den globalen Zustand von Python, was schwierig wird, wenn mehrere Benutzer gleichzeitig auf die Seite zugreifen, oder ihr bindet einen cache ein.

In unserer Blogserie haben wir Ihnen gezeigt, wie ihr den gesamten Lebenszyklus eines Data-Science-Projekts durchlauft, von der Datenexploration über das Modelltraining bis hin zur Bereitstellung und Visualisierung. Dies ist der letzte Artikel dieser Serie, und wir hoffen, ihr habt beim Erstellen der Anwendung genauso viel gelernt wie wir.

Um das Durchblättern der vier Artikel zu erleichtern, sind hier die direkten Links:

  1. Transfer Learning mit ResNet
  2. Deployment von TensorFlow-Modellen in Docker mit TensorFlow Serving
  3. Erklärbarkeit von Deep Learning Modellen mit Grad-CAM
Dominique Lade Dominique Lade

Im ersten Artikel dieser Serie über die Klassifizierung von Automodellen haben wir ein Modell gebaut, das Transfer Learning verwendet, um das Automodell durch ein Bild eines Autos zu klassifizieren. Im zweiten Beitrag haben wir gezeigt, wie TensorFlow Serving verwendet werden kann, um ein TensorFlow-Modell am Beispiel des Automodell-Classifiers einzusetzen. Diesen dritten Beitrag widmen wir einem weiteren wesentlichen Aspekt von Deep Learning und maschinellem Lernen im Allgemeinen: der Erklärbarkeit von Modellvorhersagen (englisch: Explainable AI).

Wir beginnen mit einer kurzen allgemeinen Einführung in das Thema Erklärbarkeit beim maschinellen Lernen. Als nächstes werden wir kurz auf verbreitete Methoden eingehen, die zur Erklärung und Interpretation von CNN-Vorhersagen verwendet werden können. Anschließend werden wir Grad-CAM, eine gradientenbasierte Methode, ausführlich erklären, indem wir Schritt für Schritt eine Implementierung des Verfahrens durchgehen. Zum Schluss zeigen wir Ergebnisse, die wir mit unserer Grad-CAM-Implementierung für den Auto-Modell-Classifier berechnet haben.

Eine kurze Einführung in die Erklärbarkeit von Machine Learning Modellen

In den letzten Jahren war die Erklärbarkeit ein immer wiederkehrendes Thema – aber dennoch ein Nischenthema – im Machine Learning. In den letzten vier Jahren jedoch hat das Interesse an diesem Thema stark zugenommen. Stark dazu beigetragen hat unter anderem die steigende Anzahl von Machine Learning-Modellen in der Produktion. Einerseits führt dies zu einer wachsenden Zahl von Endnutzern, die verstehen müssen, wie die Modelle Entscheidungen treffen. Andererseits müssen immer mehr Entwickler*innen von Machine Learning verstehen, warum (oder warum nicht) ein Modell auf eine bestimmte Weise funktioniert.

Dieser steigende Bedarf an Erklärbarkeit führte in den letzten Jahren zu einigen sowohl methodisch als auch technisch bemerkenswerten Innovationen:

Methoden zur Erklärung von CNN-Outputs für Bilddaten

Deep Neural Networks (DNNs) und insbesondere komplexe Architekturen wie CNNs galten lange Zeit als reine Blackbox-Modelle. Wie oben beschrieben änderte sich dies in den letzten Jahren, und inzwischen gibt es verschiedene Methoden, um CNN-Outputs zu erklären. Zum Beispiel implementiert die hervorragende Bibliothek tf-explain eine breite Palette nützlicher Methoden für TensorFlow 2.x. Wir werden nun kurz auf die Ideen der verschiedenen Ansätze eingehen, bevor wir uns Grad-CAM zuwenden:

Activations Visualization

Activations Visualization ist die einfachste Visualisierungstechnik. Hierbei wird die Ausgabe einer bestimmten Layer innerhalb des Netzwerks während des Vorwärtsdurchlaufs ausgegeben. Diese kann hilfreich sein, um ein Gefühl für die extrahierten Features zu bekommen, da die meisten Activations während des Trainings gegen Null tendieren (bei Verwendung der ReLu-Activation). Ein Beispiel für die Ausgabe der ersten Faltungsschicht des Auto-Modell-Classifiers ist unten dargestellt:

Vanilla Gradients

Man kann die Vanilla-Gradients der Ausgabe der vorhergesagten Klassen für das Eingangsbild verwenden, um die Bedeutung der Eingangspixel abzuleiten.

Wir sehen hier, dass der hervorgehobene Bereich hauptsächlich auf das Auto fokussiert ist. Im Vergleich zu den unten besprochenen Methoden ist der diskriminierende Bereich viel weniger eingegrenzt.

Occlusion Sensitivity

Bei diesem Ansatz wird die Signifikanz bestimmter Teile des Eingangsbildes berechnet, indem die Vorhersage des Modells für verschiedene ausgeblendete Teile des Eingangsbildes bewertet wird. Teile des Bildes werden iterativ ausgeblendet, indem sie durch graue Pixel ersetzt werden. Je schwächer die Vorhersage wird, wenn ein Teil des Bildes ausgeblendet ist, desto wichtiger ist dieser Teil für die endgültige Vorhersage. Basierend auf der Unterscheidungskraft der Bildregionen kann eine Heatmap erstellt und dargestellt werden. Die Anwendung der Occlusion Sensitivity für unseren Auto-Modell-Classifier hat keine aussagekräftigen Ergebnisse geliefert. Daher zeigen wir das Beispielbild von tf-explain, welches das Ergebnis der Anwendung des Verfahrens der Occlusion Sensitivity für ein Katzenbild zeigt.

CNN Fixations

Ein weiterer interessanter Ansatz namens CNN Fixations wurde in diesem Paper vorgestellt . Die Idee dabei ist, zurück zu verfolgen, welche Neuronen in jeder Schicht signifikant waren, indem man die Activations aus der Vorwärtsrechnung und die Netzwerkgewichte betrachtet. Die Neuronen mit großem Einfluss werden als Fixations bezeichnet. Dieser Ansatz erlaubt es also, die wesentlichen Regionen für das Ergebnis zu finden, ohne wiederholte Modellvorhersagen berechnen zu müssen (wie dies z.B. für die oben erklärte Occlusion Sensitivity der Fall ist).

Das Verfahren kann wie folgt beschrieben werden: Der Knoten, der der Klasse entspricht, wird als Fixation in der Ausgabeschicht gewählt. Dann werden die Fixations für die vorherige Schicht bestimmt, indem berechnet wird, welche der Knoten den größten Einfluss auf die Fixations der nächsthöheren Ebene haben, die im letzten Schritt bestimmt wurden. Die Knotengewichtung wird durch Multiplikation von Activations und Netzwerk-Gewichten errechnet. Wenn ihr an den Details des Verfahrens interessiert seid, schaut euch das Paper oder das entsprechende Github Repo an. Dieses Backtracking wird so lange durchgeführt, bis das Eingabebild erreicht ist, was eine Menge von Pixeln mit beträchtlicher Unterscheidungskraft ergibt. Ein Beispiel aus dem Paper ist unten dargestellt.

CAM

Das in diesem Paper vorgestellte Class Activation Mapping (CAM) ist ein Verfahren, um die diskriminante(n) Region(en) für eine CNN-Vorhersage durch die Berechnung von sogenannten Class Activation Maps zu finden. Ein wesentlicher Nachteil dieses Verfahrens ist, dass das Netzwerk als letzten Schritt vor der Vorhersageschicht ein Global Average Pooling (GAP) verwenden muss. Es ist daher nicht möglich, diesen Ansatz für allgemeine CNN-Architekturen anzuwenden. Ein Beispiel ist in der folgenden Abbildung dargestellt (entnommen aus dem CAM paper):

Die Class Activation Map weist jeder Position (x, y) in der letzten Faltungsschicht eine Bedeutung zu, indem sie die Linearkombination der Activations – gewichtet mit den entsprechenden Ausgangsgewichten für die beobachtete Klasse (im obigen Beispiel „Australian Terrier“) – berechnet. Die resultierende Class Activation Mapping wird dann auf die Größe des Eingabebildes hochgerechnet. Dies wird durch die oben dargestellte Heatmap veranschaulicht. Aufgrund der Architektur von CNNs ist die Aktivierung, z. B. oben links für eine beliebige Schicht, direkt mit der oberen linken Seite des Eingabebildes verbunden. Deshalb können wir nur aus der Betrachtung der letzten CNN-Schicht schließen, welche Eingabebereiche wichtig sind.

Bei dem Grad-CAM-Verfahren, das wir unten im Detail besprechen werden, handelt es sich um eine Verallgemeinerung von CAM. Grad-CAM kann auf Netzwerke mit allgemeinen CNN-Architekturen angewendet werden, die mehrere fully connected Layers am Ausgang enthalten.

Grad-CAM

Grad-CAM erweitert die Anwendbarkeit des CAM-Verfahrens durch das Einbeziehen von Gradienteninformationen. Konkret bestimmt der Gradient der Loss-Funktion in Bezug auf die letzte Faltungsschicht das Gewicht für jede der entsprechenden Feature Maps. Wie beim obigen CAM-Verfahren bestehen die weiteren Schritte in der Berechnung der gewichteten Summe der Aktivierungen und dem anschließenden Upsampling des Ergebnisses auf die Bildgröße, um das Originalbild mit der erhaltenen Heatmap darzustellen. Wir werden nun den Code, der zur Ausführung von Grad-CAM verwendet werden kann, zeigen und diskutieren. Der vollständige Code ist hier auf GitHub verfügbar.

import pickle
import tensorflow as tf
import cv2
from car_classifier.modeling import TransferModel

INPUT_SHAPE = (224, 224, 3)

# Load list of targets
file = open('.../classes.pickle', 'rb')
classes = pickle.load(file)

# Load model
model = TransferModel('ResNet', INPUT_SHAPE, classes=classes)
model.load('...')

# Gradient model, takes the original input and outputs tuple with:
# - output of conv layer (in this case: conv5_block3_3_conv)
# - output of head layer (original output)
grad_model = tf.keras.models.Model([model.model.inputs],
                                   [model.model.get_layer('conv5_block3_3_conv').output,
                                    model.model.output])

# Run model and record outputs, loss, and gradients
with tf.GradientTape() as tape:
    conv_outputs, predictions = grad_model(img)
    loss = predictions[:, label_idx]

# Output of conv layer
output = conv_outputs[0]

# Gradients of loss w.r.t. conv layer
grads = tape.gradient(loss, conv_outputs)[0]

# Guided Backprop (elimination of negative values)
gate_f = tf.cast(output > 0, 'float32')
gate_r = tf.cast(grads > 0, 'float32')
guided_grads = gate_f * gate_r * grads

# Average weight of filters
weights = tf.reduce_mean(guided_grads, axis=(0, 1))

# Class activation map (cam)
# Multiply output values of conv filters (feature maps) with gradient weights
cam = np.zeros(output.shape[0: 2], dtype=np.float32)
for i, w in enumerate(weights):
    cam += w * output[:, :, i]

# Or more elegant: 
# cam = tf.reduce_sum(output * weights, axis=2)

# Rescale to org image size and min-max scale
cam = cv2.resize(cam.numpy(), (224, 224))
cam = np.maximum(cam, 0)
heatmap = (cam - cam.min()) / (cam.max() - cam.min())

Detailbetrachtung des Codes

  • Der erste Schritt besteht darin, eine Instanz des Modells zu laden.
  • Dann erstellen wir eine neue keras.Model-Instanz, die zwei Ausgaben hat: Die Aktivierungen der letzten CNN-Schicht ('conv5_block3_3_conv') und die ursprüngliche Modellausgabe.
  • Als nächstes führen wir eine Vorwärtsrechnung für unser neues grad_model aus, wobei wir als Eingabe ein Bild ( img) der Form (1, 224, 224, 3) verwenden, das mit der Methode resnetv2.preprocess_input vorverarbeitet wurde. Zur Aufzeichnung der Gradienten wird tf.GradientTape angelegt und angewendet (die Gradienten werden hierbei im tapeObjekt gespeichert). Weiterhin werden die Ausgaben der Faltungsschicht (conv_outputs) und des heads (predictions) gespeichert. Schließlich können wir label_idx verwenden, um den Verlust zu erhalten, der dem Label entspricht, für das wir die diskriminierenden Regionen finden wollen.
  • Mit Hilfe der gradient-Methode kann man die gewünschten Gradienten aus tape extrahieren. In diesem Fall benötigen wir den Gradienten des Verlustes in Bezug auf die Ausgabe der Faltungsschicht.
  • In einem weiteren Schritt wird eine guided Backprop angewendet. Dabei werden nur Werte für die Gradienten behalten, bei denen sowohl die Aktivierungen als auch die Gradienten positiv sind. Dies bedeutet im Wesentlichen, dass die Aufmerksamkeit auf die Aktivierungen beschränkt wird, die positiv zu der gewünschten Ausgabevorhersage beitragen.
  • Die weights werden durch Mittelung der erhaltenen geführten Gradienten für jeden Filter berechnet.
  • Die Class Activation Map cam wird dann als gewichteter Durchschnitt der Aktivierungen der Feature Map (output) berechnet. Die Methode mit der obigen for-Schleife hilft zu verstehen, was die Funktion im Detail tut. Eine weniger einfache, aber effizientere Art, die CAM-Berechnung zu implementieren, ist die Verwendung von tf.reduce_mean und wird in der kommentierten Zeile unterhalb der Schleifenimplementierung gezeigt.
  • Schließlich wird das Resampling (Größenänderung) mit der resize-Methode von OpenCV2 durchgeführt, und die Heatmap wird so skaliert, dass sie Werte in [0, 1] enthält, um sie zu plotten.

Eine Version von Grad-CAM ist auch in tf-explain implementiert.

Beispiele für den Auto-Modell-Classifier

Wir verwenden nun die Grad-CAM-Implementierung, um die Vorhersagen des TransferModel für die Klassifizierung von Automodellen zu interpretieren und zu erklären. Wir beginnen mit der Betrachtung von Fahrzeugbildern, die von vorne aufgenommen wurden.


Grad-CAM für Fahrzeugaufnahmen von der Vorderseite

Die roten Regionen markieren die wichtigsten diskriminierenden Regionen, die blauen Regionen die unwichtigsten. Wir können sehen, dass sich das CNN bei Bildern von vorne auf den Kühlergrill des Autos und den Bereich des Logos konzentriert. Ist das Auto leicht gekippt, verschiebt sich der Fokus mehr auf den Rand des Fahrzeugs. Dies ist auch bei leicht gekippten Bildern von der Rückseite des Fahrzeugs der Fall, wie im mittleren Bild unten gezeigt.


Grad-CAM für Fahrzeugaufnahmen von der Rückseite

Bei Bildern von der Rückseite des Autos liegt der wichtigste Unterscheidungsbereich in der Nähe des Nummernschilds. Wie bereits erwähnt, hat bei Autos, die aus einem Winkel betrachtet werden, die nächstgelegene Ecke die höchste Trennschärfe. Ein sehr interessantes Beispiel ist die Mercedes-Benz C-Klasse auf der rechten Seite, bei der sich das Modell nicht nur auf die Rückleuchten konzentriert, sondern auch die höchste Trennschärfe auf den Modellschriftzug legt.


Grad-CAM für Fahrzeugaufnahmen von der Seite

Wenn wir Bilder von der Seite betrachten, stellen wir fest, dass die diskriminierende Region auf die untere Hälfte der Autos beschränkt ist. Auch hier bestimmt der Winkel, aus dem das Fahrzeugbild aufgenommen wurde, die Verschiebung der Region in Richtung der vorderen oder hinteren Ecke.

Im Allgemeinen ist die wichtigste Tatsache, dass die diskriminierenden Bereiche immer auf Teile der Autos beschränkt sind. Es gibt keine Bilder, bei denen der Hintergrund eine hohe Unterscheidungskraft hat. Die Betrachtung der Heatmaps und der zugehörigen diskriminierenden Regionen kann als Sanity-Check für CNN-Modelle verwendet werden.

Fazit

Wir haben mehrere Ansätze zur Erklärung von CNN-Klassifikatorausgaben diskutiert. Wir haben Grad-CAM im Detail vorgestellt, indem wir den Code untersucht und uns Beispiele für den Auto-Modell-Classifier angeschaut haben. Am auffälligsten ist, dass die durch das Grad-CAM-Verfahren hervorgehobenen diskriminierenden Regionen immer auf das Auto fokussiert sind und nie auf die Hintergründe der Bilder. Das Ergebnis zeigt, dass das Modell so funktioniert, wie wir es erwarten und spezifische Teile des Autos zur Unterscheidung zwischen verschiedenen Modellen verwendet werden.

Im vierten und letzten Teil dieser Blog-Serie werden wir zeigen, wie der Car Classifier mit Dash in eine Web-Anwendung eingebaut werden kann. Bis bald!

Stephan Müller Stephan Müller

Im ersten Beitrag dieser Serie haben wir Transfer Learning im Detail besprochen und ein Modell zur Klassifizierung von Automodellen erstellt. In diesem Beitrag werden wir das Problem der Modellbereitstellung am Beispiel des im ersten Beitrags vorgestellten TransferModel diskutieren.

Ein Modell ist in der Praxis nutzlos, wenn es keine einfache Möglichkeit gibt, damit zu interagieren. Mit anderen Worten: Wir brauchen eine API für unsere Modelle. TensorFlow Serving wurde entwickelt, um diese Funktionalitäten für TensorFlow-Modelle bereitzustellen. In diesem Beitrag zeigen wir, wie ein TensorFlow Serving Server in einem Docker-Container gestartet werden kann und wie wir mit dem Server über HTTP-Anfragen interagieren können.

Wenn ihr noch nie mit Docker gearbeitet habt, empfehlen wir, dieses Tutorial von Docker durchzuarbeiten, bevor ihr diesen Artikel lest. Wenn ihr euch ein Beispiel für das Deployment in Docker ansehen möchtet, empfehlen wir euch, diesen Blogbeitrag von unserem Kollegen Oliver Guggenbühl zu lesen, in dem beschrieben wird, wie ein R-Skript in Docker ausgeführt werden kann.

Einführung in TensorFlow Serving

Zum Einstieg geben wir euch zunächst einen Überblick über TensorFlow Serving.

TensorFlow Serving ist das Serving-System von TensorFlow, das entwickelt wurde, um das Deployment von verschiedenen Modellen mit einer einheitlichen API zu ermöglichen. Unter Verwendung der Abstraktion von Servables, die im Grunde Objekte sind, mit denen Inferenz durchgeführt werden kann, ist es möglich, mehrere Versionen von deployten Modellen zu serven. Das ermöglicht zum Beispiel, dass eine neue Version eines Modells hochgeladen werden kann, während die vorherige Version noch für Kunden verfügbar ist. Im Großen und Ganzen sind sogenannte Manager für die Verwaltung des Lebenszyklus von Servables verantwortlich, d. h. für das Laden, Bereitstellen und Löschen.

In diesem Beitrag werden wir zeigen, wie eine einzelne Modellversion deployed werden kann. Die unten aufgeführten Code-Beispiele zeigen, wie ein Server in einem Docker-Container gestartet werden kann und wie die Predict API verwendet werden kann, um mit dem Modell zu interagieren. Um mehr über TensorFlow Serving zu erfahren, verweisen wir auf die TensorFlow-Website.

Implementierung

Wir werden nun die folgenden drei Schritte besprechen, die erforderlich sind, um das Modell einzusetzen und Requests zu senden.

  • Speichern eines Modells im richtigen Format und in der richtigen Ordnerstruktur mit TensorFlow SavedModel
  • Ausführen eines Serving-Servers innerhalb eines Docker-Containers
  • Interaktion mit dem Modell über REST Requests

Speichern von TensorFlow-Modellen

Für diejenigen, die den ersten Beitrag dieser Serie nicht gelesen haben, folgt nun eine kurze Zusammenfassung der wichtigsten Punkte, die zum Verständnis des nachfolgenden Codes notwendig sind:

Das TransferModel.model (unten im Code auch self.model) ist eine tf.keras.Model Instanz, also kann es mit der eingebauten save Methode gespeichert werden. Da das Modell auf im Internet gescrapten Daten trainiert wurde, können sich die Klassenbezeichnungen beim erneuten Scraping der Daten ändern. Wir speichern daher die Index-Klassen-Zuordnung beim Speichern des Modells in classes.pickle ab. TensorFlow Serving erfordert, dass das Modell im SavedModel Format gespeichert wird. Wenn Sie tf.keras.Model.save verwenden, muss der Pfad ein Ordnername sein, sonst wird das Modell in einem anderen, inkompatiblen Format (z.B. HDF5) gespeichert. Im Code unten enthält folderpath den Pfad des Ordners, in dem wir alle modellrelevanten Informationen speichern wollen. Das SavedModel wird unter folderpath/model gespeichert und das Class Mapping wird als folderpath/classes.pickle gespeichert.

def save(self, folderpath: str):
    """
    Save the model using tf.keras.model.save

    Args:
        folderpath: (Full) Path to folder where model should be stored
    """

    # Make sure folderpath ends on slash, else fix
    if not folderpath.endswith("/"):
        folderpath += "/"

    if self.model is not None:
        os.mkdir(folderpath)
        model_path = folderpath + "model"
        # Save model to model dir
        self.model.save(filepath=model_path)
        # Save associated class mapping
        class_df = pd.DataFrame({'classes': self.classes})
        class_df.to_pickle(folderpath + "classes.pickle")
    else:
        raise AttributeError('Model does not exist')

TensorFlow Serving im Docker Container starten

Nachdem wir das Modell auf der Festplatte gespeichert haben, müssen wir nun den TensorFlow Serving Server starten. Am schnellsten deployen kann man TensorFlow Serving mithilfe eines Docker-Containers. Der erste Schritt ist daher das Ziehen des TensorFlow Serving Images von DockerHub. Das kann im Terminal mit dem Befehl docker pull tensorflow/serving gemacht werden.

Dann können wir den unten stehenden Code verwenden, um einen TensorFlow Serving Container zu starten. Er führt den Shell-Befehl zum Starten eines Containers aus. Die in docker_run_cmd gesetzten Optionen sind die folgenden:

  • Das Serving-Image exponiert Port 8501 für die REST-API, die wir später zum Senden von Anfragen verwenden werden. Wir mappen mithilfe der -p– Flag also den Host-Port 8501 auf den Port 8501 des Containers.
  • Als nächstes binden wir unser Modell mit -v in den Container ein. Es ist wichtig, dass das Modell in einem versionierten Ordner gespeichert ist (hier MODEL_VERSION=1); andernfalls wird das Serving-Image das Modell nicht finden. Der model_path_guest muss also die Form <path>/<model name>/MODEL_VERSION haben, wobei MODEL_VERSION eine ganze Zahl ist.
  • Mit -e können wir die Umgebungsvariable MODEL_NAME setzen, die den Namen unseres Modells enthält.
  • Die Option --name tf_serving wird nur benötigt, um unserem neuen Docker-Container einen bestimmten Namen zuzuweisen.

Wenn wir versuchen, diese Datei zweimal hintereinander auszuführen, wird der Docker-Befehl beim zweiten Mal nicht ausgeführt, da bereits ein Container mit dem Namen tf_serving existiert. Um dieses Problem zu vermeiden, verwenden wir docker_run_cmd_cond. Hier prüfen wir zunächst, ob ein Container mit diesem spezifischen Namen bereits existiert und läuft. Wenn ja, lassen wir ihn gleich; wenn nicht, prüfen wir, ob eine beendete Version des Containers existiert. Wenn ja, wird diese gelöscht und ein neuer Container gestartet; wenn nicht, wird direkt ein neuer Container erstellt.

import os

MODEL_FOLDER = 'models'
MODEL_SAVED_NAME = 'resnet_unfreeze_all_filtered.tf'
MODEL_NAME = 'resnet_unfreeze_all_filtered'
MODEL_VERSION = '1'

# Define paths on host and guest system
model_path_host = os.path.join(os.getcwd(), MODEL_FOLDER, MODEL_SAVED_NAME, 'model')
model_path_guest = os.path.join('/models', MODEL_NAME, MODEL_VERSION)

# Container start command
docker_run_cmd = f'docker run ' 
                 f'-p 8501:8501 ' 
                 f'-v {model_path_host}:{model_path_guest} ' 
                 f'-e MODEL_NAME={MODEL_NAME} ' 
                 f'-d ' 
                 f'--name tf_serving ' 
                 f'tensorflow/serving'

# If container is not running, create a new instance and run it
docker_run_cmd_cond = f'if [ ! "(docker ps -q -f name=tf_serving)" ]; then n'                        f'   if [ "(docker ps -aq -f status=exited -f name=tf_serving)" ]; then 														n' 
                      f'   		docker rm tf_serving n' 
                      f'   fi n' 
                      f'   {docker_run_cmd} n' 
                      f'fi'

# Start container
os.system(docker_run_cmd_cond)

Anstatt das Modell von unserer lokalen Festplatte zu mounten, indem wir das -v-Flag im Docker-Befehl verwenden, könnten wir das Modell auch in das Docker-Image kopieren, so dass das Modell einfach durch das Ausführen eines Containers und die Angabe der Port-Zuweisungen bedient werden könnte. Es ist wichtig zu beachten, dass in diesem Fall das Modell mit der Ordnerstruktur Ordnerpfad/<Modellname>/1 gespeichert werden muss, wie oben erklärt. Wenn dies nicht der Fall ist, wird der TensorFlow Serving Container das Modell nicht finden. Wir werden hier nicht weiter auf diesen Fall eingehen. Wenn ihr daran interessiert seid, eure Modelle auf diese Weise zu deployen, verweisen wir auf diese Anleitung auf der TensorFlow Webseite.

REST Request

Da das Modell nun geserved ist und bereit zur Verwendung ist, brauchen wir einen Weg, um damit zu interagieren. TensorFlow Serving bietet zwei Optionen, um Anfragen an den Server zu senden: gRCP und REST API, welche beide an unterschiedlichen Ports verfügbar sind. Im folgenden Codebeispiel werden wir REST verwenden, um das Modell abzufragen.

Zuerst laden wir ein Bild von der Festplatte, für das wir eine Vorhersage machen wollen. Dies kann mit dem image Modul von TensorFlow gemacht werden. Als nächstes konvertieren wir das Bild in ein Numpy-Array mittels der img_to_array-Methode. Der nächste und letzte Schritt ist entscheidend für unseren Car Classifier Use Case: da wir das Trainingsbild vorverarbeitet haben, bevor wir unser Modell trainiert haben (z.B. Normalisierung), müssen wir die gleiche Transformation auf das Bild anwenden, das wir vorhersagen wollen. Die praktische Funktion „preprocess_input“ sorgt dafür, dass alle notwendigen Transformationen auf unser Bild angewendet werden.

from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.resnet_v2 import preprocess_input

# Load image
img = image.load_img(path, target_size=(224, 224))
img = image.img_to_array(img)

# Preprocess and reshape data
img = preprocess_input(img)
img = img.reshape(-1, *img.shape)

Die RESTful API von TensorFlow Serving bietet mehrere Endpunkte. Im Allgemeinen akzeptiert die API Post-Requests der folgenden Struktur:

POST http://host:port/<URI>:<VERB>

URI: /v1/models/{MODEL_NAME}[/versions/{MODEL_VERSION}]
VERB: classify|regress|predict

Für unser Modell können wir die folgende URL für Vorhersagen verwenden: http://localhost:8501/v1/models/resnet_unfreeze_all_filtered:predict

Die Portnummer (hier 8501) ist der Port des Hosts, den wir oben angegeben haben, um ihn auf den Port 8501 des Serving-Images abzubilden. Wie oben erwähnt, ist 8501 der Port des Serving-Containers, der für die REST-API verwendet wird. Die Modellversion ist optional und wird standardmäßig auf die neueste Version gesetzt, wenn sie weggelassen wird.

In Python kann die Bibliothek requests verwendet werden, um HTTP-Anfragen zu senden. Wie in der Dokumentation angegeben, muss der Request-Body für die predict API ein JSON-Objekt mit den unten aufgeführten Schlüssel-Wert-Paaren sein:

  • signature_name – zu verwendende Signatur (weitere Informationen finden Sie in der Dokumentation)
  • instances – Modelleingabe im Zeilenformat
import json
import requests

# Send image as list to TF serving via json dump
request_url = 'http://localhost:8501/v1/models/resnet_unfreeze_all_filtered:predict'
request_body = json.dumps({"signature_name": "serving_default", "instances": img.tolist()})
request_headers = {"content-type": "application/json"}
json_response = requests.post(request_url, data=request_body, headers=request_headers)
response_body = json.loads(json_response.text)
predictions = response_body['predictions']

# Get label from prediction
y_hat_idx = np.argmax(predictions)
y_hat = classes[y_hat_idx]

Der Response-Body ist ebenfalls ein JSON-Objekt mit einem einzigen Schlüssel namens predictions. Da wir für jede Zeile in den Instanzen die Wahrscheinlichkeit für alle 300 Klassen erhalten, verwenden wir np.argmax, um die wahrscheinlichste Klasse zurückzugeben. Alternativ hätten wir auch die übergeordnete classify-API verwenden können.

Fazit

In diesem zweiten Blog-Artikel der Serie „Car Model Classification“ haben wir gelernt, wie ein TensorFlow-Modell zur Bilderkennung mittels TensorFlow Serving als RestAPI bereitgestellt werden kann, und wie damit Modellabfragen ausgeführt werden können.

Dazu haben wir zuerst das Modell im SavedModel Format abgespeichert. Als nächstes haben wir den TensorFlow Serving-Server in einem Docker-Container gestartet. Schließlich haben wir gezeigt, wie man Vorhersagen aus dem Modell mit Hilfe der API-Endpunkte und einem korrekt spezifizierten Request Body anfordert.

Ein Hauptkritikpunkt an Deep Learning Modellen jeglicher Art ist die fehlende Erklärbarkeit der Vorhersagen. Im dritten Beitrag werden wir zeigen, wie man Modellvorhersagen mit einer Methode namens Grad-CAM erklären kann.

Stephan Müller Stephan Müller

Deep Learning ist eines der Themen im Bereich der künstlichen Intelligenz, die uns bei STATWORX besonders faszinieren. In dieser Blogserie möchten wir veranschaulichen, wie ein End-to-end Deep Learning Projekt implementiert werden kann. Dabei verwenden wir die TensorFlow 2.x Bibliothek für die Implementierung.

Die Themen der 4-teiligen Blogserie umfassen:

  • Transfer Learning für Computer Vision
  • Deployment über TensorFlow Serving
  • Interpretierbarkeit von Deep-Learning-Modellen mittels Grad-CAM
  • Integration des Modells in ein Dashboard

Im ersten Teil zeigen wir, wie man Transfer Learning nutzen kann, um die Marke eines Autos mittels Bildklassifizierung vorherzusagen. Wir beginnen mit einem kurzen Überblick über Transfer Learning und das ResNet und gehen dann auf die Details der Implementierung ein. Der vorgestellte Code ist in diesem Github Repository zu finden.

Einführung: Transfer Learning & ResNet

Was ist Transfer Learning?

Beim traditionellen (Machine) Learning entwickeln wir ein Modell und trainieren es auf neuen Daten für jede neue Aufgabe, die ansteht. Transfer Learning unterscheidet sich von diesem Ansatz dadurch, dass das gesammelte Wissen von einer Aufgabe auf eine andere übertragen wird. Dieser Ansatz ist besonders nützlich, wenn einem zu wenige Trainingsdaten zur Verfügung stehen. Modelle, die für ein ähnliches Problem vortrainiert wurden, können als Ausgangspunkt für das Training neuer Modelle verwendet werden. Die vortrainierten Modelle werden als Basismodelle bezeichnet.

In unserem Beispiel kann ein Deep Learning-Modell, das auf dem ImageNet-Datensatz trainiert wurde, als Ausgangspunkt für die Erstellung eines Klassifikationsnetzwerks für Automodelle verwendet werden. Die Hauptidee hinter dem Transfer Learning für Deep Learning-Modelle ist, dass die ersten Layer eines Netzwerks verwendet werden, um wichtige High-Level-Features zu extrahieren, die für die jeweilige Art der behandelten Daten ähnlich bleiben. Die finalen Layer, auch „head“ genannt, des ursprünglichen Netzwerks werden durch einen benutzerdefinierten head ersetzt, der für das vorliegende Problem geeignet ist. Die Gewichte im head werden zufällig initialisiert, und das resultierende Netz kann für die spezifische Aufgabe trainiert werden.

Es gibt verschiedene Möglichkeiten, wie das Basismodell beim Training behandelt werden kann. Im ersten Schritt können seine Gewichte fixiert werden. Wenn der Lernfortschritt darauf schließen lässt, dass das Modell nicht flexibel genug ist, können bestimmte Layer oder das gesamte Basismodell auch mit trainiert werden. Ein weiterer wichtiger Aspekt, den es zu beachten gilt, ist, dass der Input die gleiche Dimensionalität haben muss wie die Daten, auf denen das Basismodell initial trainiert wurde – sofern die ersten Layer des Basismodells festgehalten werden sollen.

image-20200319174208670

Als nächstes stellen wir kurz das ResNet vor, eine beliebte und leistungsfähige CNN-Architektur für Bilddaten. Anschließend zeigen wir, wie wir Transfer Learning mit ResNet zur Klassifizierung von Automodellen eingesetzt haben.

Was ist ResNet?

Das Training von Deep Neural Networks kann aufgrund des sogenannten Vanishing Gradient-Problems schnell zur Herausforderung werden. Aber was sind Vanishing Gradients? Neuronale Netze werden in der Regel mit Back-Propagation trainiert. Dieser Algorithmus nutzt die Kettenregel der Differentialrechnung, um Gradienten in tieferen Layern des Netzes abzuleiten, indem Gradienten aus früheren Layern multipliziert werden. Da Gradienten in Deep Networks wiederholt multipliziert werden, können sie sich während der Backpropagation schnell infinitesimal kleinen Werten annähern.

ResNet ist ein CNN-Netz, welches das Problem des Vanishing Gradients mit sogenannten Residualblöcken löst (eine gute Erklärung, warum sie ‚Residual‘ heißen, findest du hier). Im Residualblock wird die unmodifizierte Eingabe an das nächste Layer weitergereicht, indem sie zum Ausgang eines Layers addiert wird (siehe Abbildung rechts). Diese Modifikation sorgt dafür, dass ein besserer Informationsfluss von der Eingabe zu den tieferen Layers möglich ist. Die gesamte ResNet-Architektur ist im rechten Netzwerk in der linken Abbildung unten dargestellt. Weiter sind daneben ein klassisches CNN und das VGG-19-Netzwerk, eine weitere Standard-CNN-Architektur, abgebildet.

Resnet-Architecture_Residual-Block

ResNet hat sich als leistungsfähige Netzarchitektur für Bildklassifikationsprobleme erwiesen. Zum Beispiel hat ein Ensemble von ResNets mit 152 Layern den ILSVRC 2015 Bildklassifikationswettbewerb gewonnen. Im Modul tensorflow.keras.application sind vortrainierte ResNet-Modelle unterschiedlicher Größe verfügbar, nämlich ResNet50, ResNet101, ResNet152 und die entsprechenden zweiten Versionen (ResNet50V2, …). Die Zahl hinter dem Modellnamen gibt die Anzahl der Layer an, über die die Netze verfügen. Die verfügbaren Gewichte sind auf dem ImageNet-Datensatz vortrainiert. Die Modelle wurden auf großen Rechenclustern unter Verwendung von spezialisierter Hardware (z.B. TPU) über signifikante Zeiträume trainiert. Transfer Learning ermöglicht es uns daher, diese Trainingsergebnisse zu nutzen und die erhaltenen Gewichte als Ausgangspunkt zu verwenden.

Klassifizierung von Automodellen

Als anschauliches Beispiel für die Anwendung von Transfer Learning behandeln wir das Problem der Klassifizierung des Automodells anhand eines Bildes des Autos. Wir beginnen mit der Beschreibung des verwendeten Datensatzes und wie wir unerwünschte Beispiele aus dem Datensatz herausfiltern können. Anschließend gehen wir darauf ein, wie eine Datenpipeline mit tensorflow.data eingerichtet werden kann. Im zweiten Abschnitt werden wir die Modellimplementierung durchgehen und aufzeigen, auf welche Aspekte ihr beim Training und bei der Inferenz besonders achten müsst.

Datenvorbereitung

Wir haben den Datensatz aus diesem GitHub Repo verwendet – dort könnt ihr den gesamten Datensatz herunterladen. Der Autor hat einen Datascraper gebaut, um alle Autobilder von der Car Connection Website zu scrapen. Er erklärt, dass viele Bilder aus dem Innenraum der Autos stammen. Da sie im Datensatz nicht erwünscht sind, filtern wir sie anhand der Pixelfarbe heraus. Der Datensatz enthält 64’467 jpg-Bilder, wobei die Dateinamen Informationen über die Automarke, das Modell, das Baujahr usw. enthalten. Für einen detaillierteren Einblick in den Datensatz empfehlen wir euch, das originale GitHub Repo zu konsultieren. Hier sind drei Beispielbilder:

Car Collage 01

Bei der Betrachtung der Daten haben wir festgestellt, dass im Datensatz noch viele unerwünschte Bilder enthalten waren, z.B. Bilder von Außenspiegeln, Türgriffen, GPS-Panels oder Leuchten. Beispiele für unerwünschte Bilder sind hier zu sehen:

Car Collage 02

Daher ist es von Vorteil, die Daten zusätzlich vorzufiltern, um mehr unerwünschte Bilder zu entfernen.

Filtern unerwünschter Bilder aus dem Datensatz

Es gibt mehrere mögliche Ansätze, um Nicht-Auto-Bilder aus dem Datensatz herauszufiltern:

  1. Verwendung eines vortrainierten Modells
  2. Ein anderes Modell trainieren, um Auto/Nicht-Auto zu klassifizieren
  3. Trainieren eines Generative Networks auf einem Auto-Datensatz und Verwendung des Diskriminatorteil des Netzwerks

Wir haben uns für den ersten Ansatz entschieden, da er der direkteste ist und ausgezeichnete, vortrainierte Modelle leicht verfügbar sind. Wenn ihr den zweiten oder dritten Ansatz verfolgen wollt, könnt ihr z. B. diesen Datensatz verwenden, um das Modell zu trainieren. Dieser Datensatz enthält nur Bilder von Autos, ist aber deutlich kleiner als der von uns verwendete Datensatz.

Unsere Wahl fiel auf das ResNet50V2 im Modul tensorflow.keras.applications mit den vortrainierten „imagenet“-Gewichten. In einem ersten Schritt müssen wir jetzt die Indizes und Klassennamen der imagenet-Labels herausfinden, die den Autobildern entsprechen.

# Class labels in imagenet corresponding to cars
CAR_IDX = [656, 627, 817, 511, 468, 751, 705, 757, 717, 734, 654, 675, 864, 609, 436]

CAR_CLASSES = ['minivan', 'limousine', 'sports_car', 'convertible', 'cab', 'racer', 'passenger_car', 'recreational_vehicle', 'pickup', 'police_van', 'minibus', 'moving_van', 'tow_truck', 'jeep', 'landrover', 'beach_wagon']

Als nächstes laden wir das vortrainierte ResNet50V2-Modell.

from tensorflow.keras.applications import ResNet50V2

model = ResNet50V2(weights='imagenet')

Wir können dieses Modell nun verwenden, um die Bilder zu klassifizieren. Die Bilder, die der Vorhersagemethode zugeführt werden, müssen identisch skaliert sein wie die Bilder, die zum Training verwendet wurden. Die verschiedenen ResNet-Modelle werden auf unterschiedlich skalierten Bilddaten trainiert. Es ist daher wichtig, das richtige Preprocessing anzuwenden.

from tensorflow.keras.applications.resnet_v2 import preprocess_input

image = tf.io.read_file(filename)
image = tf.image.decode_jpeg(image)
image = tf.cast(image, tf.float32)
image = tf.image.resize_with_crop_or_pad(image, target_height=224, target_width=224)
image = preprocess_input(image)
predictions = model.predict(image)

Es gibt verschiedene Ideen, wie die erhaltenen Vorhersagen für die Autoerkennung verwendet werden können.

  • Ist eine der CAR_CLASSES unter den Top-k-Vorhersagen?
  • Ist die kumulierte Wahrscheinlichkeit der CAR_CLASSES in den Vorhersagen größer als ein definierter Schwellenwert?
  • Spezielle Behandlung unerwünschter Bilder (z. B. Erkennen und Herausfiltern von Rädern)?

Wir zeigen den Code für den Vergleich der kumulierten Wahrscheinlichkeitsmaße über die CAR_CLASSES.

def is_car_acc_prob(predictions, thresh=THRESH, car_idx=CAR_IDX):
    """
    Determine if car on image by accumulating probabilities of car prediction and comparing to threshold

    Args:
        predictions: (?, 1000) matrix of probability predictions resulting from ResNet with                                              imagenet weights
        thresh: threshold accumulative probability over which an image is considered a car
        car_idx: indices corresponding to cars

    Returns:
        np.array of booleans describing if car or not
    """
    predictions = np.array(predictions, dtype=float)
    car_probs = predictions[:, car_idx]
    car_probs_acc = car_probs.sum(axis=1)
    return car_probs_acc > thresh

Je höher der Schwellenwert eingestellt ist, desto strenger ist das Filterverfahren. Ein Wert für den Schwellenwert, der gute Ergebnisse liefert, ist THRESH = 0.1. Damit wird sichergestellt, dass nicht zu viele echte Bilder von Autos verloren gehen. Die Wahl eines geeigneten Schwellenwerts bleibt jedoch eine subjektive Angelegenheit.

Das Colab-Notebook, in dem die Funktion is_car_acc_prob zum Filtern des Datensatzes verwendet wird, ist im GitHub Repository verfügbar.

Bei der Abstimmung der Vorfilterung haben wir Folgendes beobachtet:

  • Viele der Autobilder mit hellem Hintergrund wurden als „Strandwagen“ klassifiziert. Wir haben daher entschieden, auch die Klasse „Strandwagen“ in imagenet als eine der CAR_CLASSES zu berücksichtigen.
  • Bilder, die die Front eines Autos zeigen, bekommen oft eine hohe Wahrscheinlichkeit der Klasse „Kühlergrill“ („grille“) zugeordnet, d.h. dem Gitter an der Front eines Autos, das zur Kühlung dient. Diese Zuordnung ist korrekt, führt aber dazu, dass die oben gezeigte Prozedur bestimmte Bilder von Autos nicht als Autos betrachtet, da wir „grille“ nicht in die CAR_CLASSES aufgenommen haben. Dieses Problem führt zu dem Kompromiss, entweder viele Nahaufnahmen von Autokühlergrills im Datensatz zu belassen oder einige Autobilder herauszufiltern. Wir haben uns für den zweiten Ansatz entschieden, da er einen saubereren Datensatz ergibt.

Nach der Vorfilterung der Bilder mit dem vorgeschlagenen Verfahren verbleiben zunächst 53’738 von 64’467 im Datensatz.

Übersicht über die endgültigen Datensätze

Der vorgefilterte Datensatz enthält Bilder von 323 Automodellen. Wir haben uns dazu entschieden, unsere Aufmerksamkeit auf die 300 häufigsten Klassen im Datensatz zu reduzieren. Das ist deshalb sinnvoll, da einige der am wenigsten häufigen Klassen weniger als zehn Repräsentanten haben und somit nicht sinnvoll in ein Trainings-, Validierungs- und Testset aufgeteilt werden können. Reduziert man den Datensatz auf die Bilder der 300 häufigsten Klassen, erhält man einen Datensatz mit 53.536 beschrifteten Bildern. Die Klassenvorkommen sind wie folgt verteilt:

Histogram

Die Anzahl der Bilder pro Klasse (Automodell) reicht von 24 bis knapp unter 500. Wir können sehen, dass der Datensatz sehr unausgewogen ist. Dies muss beim Training und bei der Auswertung des Modells unbedingt beachtet werden.

Aufbau von Datenpipelines mit tf.data

Selbst nach der Vorfilterung und der Reduktion auf die besten 300 Klassen bleiben immer noch zahlreiche Bilder übrig. Dies stellt ein potenzielles Problem dar, da wir nicht einfach alle Bilder auf einmal in den Speicher unserer GPU laden können. Um dieses Problem zu lösen, werden wir tf.data verwenden.

Mit tf.data und insbesondere der tf.data.Dataset API lassen sich elegante und gleichzeitig sehr effiziente Eingabe-Pipelines erstellen. Die API enthält viele allgemeine Methoden, die zum Laden und Transformieren potenziell großer Datensätze verwendet werden können. Die Methode tf.data.Dataset ist besonders nützlich, wenn Modelle auf GPU(s) trainiert werden. Es ermöglicht das Laden von Daten von der Festplatte, wendet on-the-fly Transformationen an und erstellt Batches, die dann an die GPU gesendet werden. Und das alles geschieht so, dass die GPU nie auf neue Daten warten muss.

Die folgenden Funktionen erstellen eine <code>tf.data.Dataset-Instanz für unseren konkreten Anwendungsfall:

def construct_ds(input_files: list,
                 batch_size: int,
                 classes: list,
                 label_type: str,
                 input_size: tuple = (212, 320),
                 prefetch_size: int = 10,
                 shuffle_size: int = 32,
                 shuffle: bool = True,
                 augment: bool = False):
    """
    Function to construct a tf.data.Dataset set from list of files

    Args:
        input_files: list of files
        batch_size: number of observations in batch
        classes: list with all class labels
        input_size: size of images (output size)
        prefetch_size: buffer size (number of batches to prefetch)
        shuffle_size: shuffle size (size of buffer to shuffle from)
        shuffle: boolean specifying whether to shuffle dataset
        augment: boolean if image augmentation should be applied
        label_type: 'make' or 'model'

    Returns:
        buffered and prefetched tf.data.Dataset object with (image, label) tuple
    """
    # Create tf.data.Dataset from list of files
    ds = tf.data.Dataset.from_tensor_slices(input_files)

    # Shuffle files
    if shuffle:
        ds = ds.shuffle(buffer_size=shuffle_size)

    # Load image/labels
    ds = ds.map(lambda x: parse_file(x, classes=classes, input_size=input_size,                                                                                                                                        label_type=label_type))

    # Image augmentation
    if augment and tf.random.uniform((), minval=0, maxval=1, dtype=tf.dtypes.float32, seed=None, name=None) < 0.7:
        ds = ds.map(image_augment)

    # Batch and prefetch data
    ds = ds.batch(batch_size=batch_size)
    ds = ds.prefetch(buffer_size=prefetch_size)

    return ds

Wir werden nun die verwendeten tf.data-Methoden beschreiben:

  • from_tensor_slices() ist eine der verfügbaren Methoden für die Erstellung eines Datensatzes. Der erzeugte Datensatz enthält Slices des angegebenen Tensors, in diesem Fall die Dateinamen.
  • Als nächstes betrachtet die Methode shuffle() jeweils buffer_size-Elemente separat und mischt diese Elemente isoliert vom Rest des Datensatzes. Wenn das Mischen des gesamten Datensatzes erforderlich ist, muss buffer_size größer sein als die Anzahl der Einträge im Datensatz. Das Mischen wird nur durchgeführt, wenn shuffle=True gesetzt ist.
  • Mit map() lassen sich beliebige Funktionen auf den Datensatz anwenden. Wir haben eine Funktion parse_file() erstellt, die im GitHub Repo zu finden ist. Sie ist verantwortlich für das Lesen und die Größenänderung der Bilder, das Ableiten der Beschriftungen aus dem Dateinamen und die Kodierung der Beschriftungen mit einem One-Hot-Encoder. Wenn die Flag „augment“ gesetzt ist, wird das Verfahren zur Datenerweiterung aktiviert. Die Augmentierung wird nur in 70 % der Fälle angewendet, da es von Vorteil ist, das Modell auch auf nicht modifizierten Bildern zu trainieren. Die in image_augment verwendeten Augmentierungstechniken sind Flipping, Helligkeits- und Kontrastanpassungen.
  • Schließlich wird die Methode batch() verwendet, um den Datensatz in Batches der Größe batch_size zu gruppieren, und die Methode prefetch() ermöglicht die Vorbereitung späterer Batches, während der aktuelle Batch verarbeitet wird, und verbessert so die Leistung. Wenn die Methode nach einem Aufruf von batch() verwendet wird, werden prefetch_size-Batches vorab geholt.

Fine Tuning des Modells

Nachdem wir unsere Eingabe-Pipeline definiert haben, wenden wir uns nun dem Trainingsteil des Modells zu. Der Code unten zeigt auf, wie ein Modell basierend auf dem vortrainierten ResNet instanziiert werden kann:

from tensorflow.keras.applications import ResNet50V2
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D


class TransferModel:

    def __init__(self, shape: tuple, classes: list):
        """
        Class for transfer learning from ResNet

        Args:
            shape: Input shape as tuple (height, width, channels)
            classes: List of class labels
        """
        self.shape = shape
        self.classes = classes
        self.history = None
        self.model = None

        # Use pre-trained ResNet model
        self.base_model = ResNet50V2(include_top=False,
                                     input_shape=self.shape,
                                     weights='imagenet')

        # Allow parameter updates for all layers
        self.base_model.trainable = True

        # Add a new pooling layer on the original output
        add_to_base = self.base_model.output
        add_to_base = GlobalAveragePooling2D(data_format='channels_last', name='head_gap')(add_to_base)

        # Add new output layer as head
        new_output = Dense(len(self.classes), activation='softmax', name='head_pred')(add_to_base)

        # Define model
        self.model = Model(self.base_model.input, new_output)

Ein paar weitere Details zum oben stehenden Code:

  • Wir erzeugen zunächst eine Instanz der Klasse tf.keras.applications.ResNet50V2. Mit include_top=False weisen wir das vortrainierte Modell an, den ursprünglichen head des Modells (in diesem Fall für die Klassifikation von 1000 Klassen auf ImageNet ausgelegt) wegzulassen.
  • Mit base_model.trainable = True werden alle Layer trainierbar.
  • Mit der funktionalen API tf.keras stapeln wir dann ein neues Pooling-Layer auf den letzten Faltungsblock des ursprünglichen ResNet-Modells. Dies ist ein notwendiger Zwischenschritt, bevor die Ausgabe an die endgültigen Klassifizierungs-Layer weitergeleitet wird.
  • Die endgültigen Klassifizierungs-Layer wird dann mit „tf.keras.layers.Dense“ definiert. Wir definieren die Anzahl der Neuronen so, dass sie gleich der Anzahl der gewünschten Klassen ist. Und die Softmax-Aktivierungsfunktion sorgt dafür, dass die Ausgabe eine Pseudowahrscheinlichkeit im Bereich von (0,1] ist.

Die Vollversion von TransferModel (s. GitHub) enthält auch die Option, das Basismodell durch ein VGG16-Netzwerk zu ersetzen, ein weiteres Standard-CNN für die Bildklassifikation. Außerdem erlaubt es, nur bestimmte Layer freizugeben, d.h. wir können die entsprechenden Parameter trainierbar machen, während wir die anderen festgehalten werden. Standardmässig haben wir hier alle Parameter trainierbar gemacht.

Nachdem wir das Modell definiert haben, müssen wir es für das Training konfigurieren. Dies kann mit der compile()-Methode von tf.keras.Model gemacht werden:

def compile(self, **kwargs):
      """
    Compile method
    """
    self.model.compile(**kwargs)

Wir übergeben dann die folgenden Keyword-Argumente an unsere Methode:

  • loss = "categorical_crossentropy" für die Mehrklassen-Klassifikation,
  • optimizer = Adam(0.0001) für die Verwendung des Adam-Optimierers aus tf.keras.optimizers mit einer relativ kleinen Lernrate (mehr zur Lernrate weiter unten), und
  • metrics = ["categorical_accuracy"] für die Trainings- und Validierungsüberwachung.

Als Nächstes wollen wir uns das Trainingsverfahren ansehen. Dazu definieren wir eine train-Methode für unsere oben vorgestellte TransferModel-Klasse:

from tensorflow.keras.callbacks import EarlyStopping

def train(self,
          ds_train: tf.data.Dataset,
          epochs: int,
          ds_valid: tf.data.Dataset = None,
          class_weights: np.array = None):
    """
    Trains model in ds_train with for epochs rounds

    Args:
        ds_train: training data as tf.data.Dataset
        epochs: number of epochs to train
        ds_valid: optional validation data as tf.data.Dataset
        class_weights: optional class weights to treat unbalanced classes

    Returns
        Training history from self.history
    """

    # Define early stopping as callback
    early_stopping = EarlyStopping(monitor='val_loss',
                                   min_delta=0,
                                   patience=12,
                                   restore_best_weights=True)

    callbacks = [early_stopping]

    # Fitting
    self.history = self.model.fit(ds_train,
                                  epochs=epochs,
                                  validation_data=ds_valid,
                                  callbacks=callbacks,
                                  class_weight=class_weights)

    return self.history

Da unser Modell eine Instanz von tensorflow.keras.Model ist, können wir es mit der Methode fit trainieren. Um Overfitting zu verhindern, wird Early Stopping verwendet, indem es als Callback-Funktion an die fit-Methode übergeben wird. Der patience-Parameter kann eingestellt werden, um festzulegen, wie schnell das Early Stopping angewendet werden soll. Der Parameter steht für die Anzahl der Epochen, nach denen, wenn keine Abnahme des Validierungsverlustes registriert wird, das Training abgebrochen wird. Weiterhin können Klassengewichte an die Methode fit übergeben werden. Klassengewichte erlauben es, unausgewogene Daten zu behandeln, indem den verschiedenen Klassen unterschiedliche Gewichte zugewiesen werden, wodurch die Wirkung von Klassen mit weniger Trainingsbeispielen erhöht werden kann.

Wir können den Trainingsprozess mit einem vortrainierten Modell wie folgt beschreiben: Da die Gewichte im head zufällig initialisiert werden und die Gewichte des Basismodells vortrainiert sind, setzt sich das Training aus dem Training des heads von Grund auf und der Feinabstimmung der Gewichte des vortrainierten Modells zusammen. Es wird generell für Transfer Learning empfohlen, eine kleine Lernrate zu verwenden (z. B. 1e-4), da eine zu große Lernrate die nahezu optimalen vortrainierten Gewichte des Basismodells zerstören kann.

Der Trainingsvorgang kann beschleunigt werden, indem zunächst einige Epochen lang trainiert wird, ohne dass das Basismodell trainierbar ist. Der Zweck dieser ersten Epochen ist es, die Gewichte des heads an das Problem anzupassen. Dies beschleunigt das Training, da wenn nur der head trainiert wird, viel weniger Parameter trainierbar sind und somit für jeden Batch aktualisiert werden. Die resultierenden Modellgewichte können dann als Ausgangspunkt für das Training des gesamten Modells verwendet werden, wobei das Basismodell trainierbar ist. Für das hier betrachtete Autoklassifizierungsproblem führte die Anwendung dieses zweistufigen Trainings zu keiner nennenswerten Leistungsverbesserung.

Evaluation/Vorhersage der Modell Performance

Bei der Verwendung der API tf.data.Dataset muss man auf die Art der verwendeten Methoden achten. Die folgende Methode in unserer Klasse TransferModel kann als Vorhersagemethode verwendet werden.

def predict(self, ds_new: tf.data.Dataset, proba: bool = True):
    """
    Predict class probs or labels on ds_new
    Labels are obtained by taking the most likely class given the predicted probs

    Args:
        ds_new: New data as tf.data.Dataset
        proba: Boolean if probabilities should be returned

    Returns:
        class labels or probabilities
    """

    p = self.model.predict(ds_new)

    if proba:
        return p
    else:
        return [np.argmax(x) for x in p]

Es ist wichtig, dass der Datensatz ds_new nicht gemischt wird, sonst stimmen die erhaltenen Vorhersagen nicht mit den erhaltenen Bildern überein, wenn ein zweites Mal über den Datensatz iteriert wird. Dies ist der Fall, da die Flag reshuffle_each_iteration in der Implementierung der Methode shuffle standardmäßig auf True gesetzt ist. Ein weiterer Effekt des Shufflens ist, dass mehrere Aufrufe der Methode take nicht die gleichen Daten zurückgeben. Dies ist wichtig, wenn z. B. Vorhersagen für nur eine Charge überprüft werden sollen. Ein einfaches Beispiel, an dem dies zu sehen ist, ist:

# Use construct_ds method from above to create a shuffled dataset
ds = construct_ds(..., shuffle=True)

# Take 1 batch (e.g. 32 images) of dataset: This returns a new dataset
ds_batch = ds.take(1)

# Predict labels for one batch
predictions = model.predict(ds_batch)

# Predict labels again: The result will not be the same as predictions above due to shuffling
predictions_2 = model.predict(ds_batch)

Eine Funktion zum Plotten von Bildern, die mit den entsprechenden Vorhersagen beschriftet sind, könnte wie folgt aussehen:

def show_batch_with_pred(model, ds, classes, rescale=True, size=(10, 10), title=None):
      for image, label in ds.take(1):
        image_array = image.numpy()
        label_array = label.numpy()
        batch_size = image_array.shape[0]
        pred = model.predict(image, proba=False)
        for idx in range(batch_size):
            label = classes[np.argmax(label_array[idx])]
            ax = plt.subplot(np.ceil(batch_size / 4), 4, idx + 1)
            if rescale:
                plt.imshow(image_array[idx] / 255)
            else:
                plt.imshow(image_array[idx])
            plt.title("label: " + label + "n" 
                      + "prediction: " + classes[pred[idx]], fontsize=10)
            plt.axis('off')

Die Methode show_batch_with_pred funktioniert auch für gemischte Datensätze, da image und label demselben Aufruf der Methode take entsprechen.

Die Auswertung der Model-Performance kann mit der Methode evaluate von keras.Model durchgeführt werden.

Wie akkurat ist unser finales Modell?

Das Modell erreicht eine kategoriale Genauigkeit von etwas über 70 % für die Vorhersage des Automodells für Bilder aus 300 Modellklassen. Um die Vorhersagen des Modells besser zu verstehen, ist es hilfreich, die Konfusionsmatrix zu betrachten. Unten ist die Heatmap der Vorhersagen des Modells für den Validierungsdatensatz abgebildet.

heatmap

Wir haben die Heatmap auf Einträge der Konfusionsmatrix in [0, 5] beschränkt, da das Zulassen einer weiteren Spanne keine Region außerhalb der Diagonalen signifikant hervorgehoben hat. Wie in der Heatmap zu sehen ist, wird eine Klasse den Beispielen fast aller Klassen zugeordnet. Das ist an der dunkelroten vertikalen Linie zwei Drittel rechts in der Abbildung oben zu erkennen.

Abgesehen von der zuvor erwähnten Klasse gibt es keine offensichtlichen Verzerrungen in den Vorhersagen. Wir möchten an dieser Stelle betonen, dass die Accuracy im Allgemeinen nicht ausreicht, um die Leistung eines Modells zufriedenstellend zu beurteilen, insbesondere im Fall unausgewogener Klassen.

Fazit und nächste Schritte

In diesem Blog-Beitrag haben wir Transfer Learning mit dem ResNet50V2 angewendet, um das Fahrzeugmodell anhand von Bildern von Autos zu klassifizieren. Unser Modell erreicht 70% kategoriale Genauigkeit über 300 Klassen.

Wir haben festgestellt, dass das Trainieren des gesamten Basismodells und die Verwendung einer kleinen Lernrate die besten Ergebnisse erzielen. Ein cooles Auto-Klassifikationsmodell entwickelt zu haben ist großartig, aber wie können wir unser Modell in einer produktiven Umgebung einsetzen? Natürlich könnten wir unsere eigene Modell-API mit Flask oder FastAPI bauen… Aber gibt es vielleicht sogar einen einfacheren, standardisierten Weg?

Im zweiten Beitrag unserer Blog-Serie, „Deployment von TensorFlow-Modellen in Docker mit TensorFlow Serving“ zeigen wir Euch, wie dieses Modell mit TensorFlow Serving bereitgestellt werden kann.

Stephan Müller Stephan Müller

Von der Zeichenbank zum Machine Learning Forschungsprojekt

Als eine der führenden Beratungen im Bereich Data Science, KI & Machine Learning treffen wir bei STATWORX regelmäßig Menschen, die uns mit ihren revolutionierenden Ideen nachhaltig beeindrucken. Eines haben viele dieser Menschen mit ihren Produktideen gemeinsam: Sie wollen einen persönlichen pain point in ihrer Arbeitweise verringern. Einer dieser spannenden Menschen mit einer außergewöhnlichen Idee ist Marco Limm.


Bild 1: Marco Limm, Gründer des Startups creaition

Marco Limm hat das Start-up creaition gegründet, das mit seinem Produkt den äußerst komplexen und sehr iterativen Prozess der Designentwicklung optimieren möchte. Aber wie er auf diese Idee?

Während seines Studiums im Bereich Transportdesign in den USA kam ihm erstmals die Idee, den Designprozess mit Hilfe von Machine Learning zu optimieren. Dazu motiviert hat ihn, dass viele seiner Arbeiten, um es in seinen Worten zu sagen, „für die Tonne“ produziert wurden und er dadurch angespornt wurde, einen effizienteren Weg zu finden.

Die Idee, ein eigenes Produkt zu entwickeln, dass als digitale Muse für Designer*innen fungiert, umtrieb Marco bereits seit dem 3. Semester sehr stark. Mit der Motivation, auch anderen Designer*innen damit die Arbeit zu erleichtern, und angespornt von der Neugier, ob seine Idee tatsächlich umsetzbar ist, entwickelte er aus der Idee eine Forschungsarbeit, der er sich sowohl für seine Bachelor- als auch seine Masterarbeit widmete.

Die Entwicklung des creaition Prototypen

Erste Versuche mit 3D Modellen, Bilddaten & knappen Ressourcen

Marco sieht den wichtigsten Einfluss von Designer*innen am Anfang und Ende des klassischen Designprozesses – darauf müssten sich Designer*innen seiner Meinung nach viel stärker konzentrieren können. Der mittlere Part des Designprozesses umfasst z.B. „stundenlanges Auto-Fronten zeichnen“, so Marco. „Die Morphologie kann die Maschine übernehmen, dafür braucht man keinen menschlichen Designer.“

Abbildung eines Designprozesses
Bild 2: Abbildung der klassischen Struktur des Designprozesses und des interaktiven Aufbaus.

Basierend auf der Grundidee der Optimierung durch Machine Learning startete Marco zusammen mit Kevin German, im Rahmen der gemeinsamen Bachelorarbeit an der Uni, die Entwicklung des Algorithmus. Ziel war es, eine künstliche Intelligenz (KI) zu trainieren, die selbstständig Design-Vorschläge basierend auf historischen Daten kreiert.

Zuerst hat das Duo versucht, mit 3D Modellen zu arbeiten, die Marco selbst erstellt hatte. Bei diesem Versuch stießen die beiden schnell an ihre Grenzen, da ihnen in der Uni nicht die ausreichende Rechenleistung und Infrastruktur zur Verfügung stand. Ein weiteres Problem waren zudem mangelnde Daten.

In einem zweiten Schritt versuchten sie sich an Bildern, die sie aus verschiedenen Quellen bezogen (Archive, Online etc.). Das hat zwar schon besser funktioniert, aber die Ergebnisse, die der Algorithmus aus diesen Daten generierte, waren mehr Kunst als Industriedesign. Einer seiner Professoren hätte diese Ergebnisse gerne als Kunstprojekt veröffentlicht, erzählt uns Marco. „Es kamen zwar schöne Kompositionen dabei raus, die man sicherlich in ein Museum stellen könnte, aber leider war das nicht das eigentlich Ziel.“


Bild 3: In einem „Picture Book“ zeigt Marco Limm die Ergebnisse der verschiedenen Phasen der Entwicklung des Machine Learning Algorithmus‘.

3-Layer Ansatz für den Machine Learning Algorithmus

Aus diesen ersten beiden gescheiterten Versuchen konnte die Erkenntnis gezogen werden, dass sie eine weniger komplexe, aber auch nicht zu abstrakte Datengrundlage brauchten. Es ging noch einmal zurück in die Recherche-Phase, Bücher wälzen, verschiedene Ansätze prüfen, neue Eindrücke sammeln. Das hatte zur Folge, dass sie im dritten Anlauf mit einem ganz neuen Ansatz starteten. Bei diesem neuen Ansatz unterteilten sie das Design in 3 Layer: Silhouette, Flächen, Grafiken. Die drei Layer, aus denen sich ein Design zusammensetzt, haben sie genutzt, um die Komplexität der Daten zu verringern.


Bild 4:  Auf dieser Zeichnung von Marco Limm sind man eine Auswahl der zahlreichen Entwürfe, die bei dem klassischen Designprozess vonnöten sind.

Mit dem 3-Layer Ansatz konnte Marco einen geeigneten Datensatz anlegen und mit diesen Daten den Algorithmus trainieren. Dabei heraus kamen 40.000 Designs, aus denen sie nun wählen konnten.

Aus diesem Ergebnis erwuchs die nächste Herausforderung: 40.000 Design zu evaluieren stellte keine wirkliche Arbeitserleichterung dar. Die Lösung? Ein genetischer Algorithmus, der aufgrund der Reaktionen der Designer*innen auf verschiedene Design-Vorschläge den individuellen Geschmack erkennt und darauf basierend neue Vorschläge generiert. Genannt haben sie das „Bottle-Tinder“ – denn auch hier swiped man weiter, je nachdem, ob einem das Design gefällt, oder nicht.

Beim „Bottle-Tinder“-Prinzip werden den Designer*innen immer wieder neue Designvorschläge präsentiert, die sie dann bewerten müssen. Nach etwa 15 Minuten kann der Algorithmus den Geschmack der Person extrahieren und anschließend beliebig anwenden.


Bild 5: In diesem Rendering ist das erste von der KI generierte Flaschendesign abgebildet.

Creaition unterwegs auf nationalen und internationalen Messen

Mit diesem Prototypen im Gepäck machte das Projekt creaition auf verschiedenen Messen auf sich aufmerksam und erhielt dort durchweg positives Feedback bekommen. Ihre Kolleg*innen aus der Designbranche sehen in ihrem Produkt ein hohes Potenzial – wer hat schon Lust auf stundenlanges Auto-Fronten zeichnen?

Creaition war u.a. bei folgenden Messen vertreten:

Next steps: Pilotprojekt

Wir von STATWORX unterstützen creaition aktuell bei Suche nach einem geeigneten Partner für ein Pilotprojekt. Ziel des Proof of Concepts ist die Entwicklung neuer Design-Entwürfe basierend auf extrahierter Design-DNA des Auftraggebers.

Konkret bedeutet das, dass der Machine Learning Algorithmus auf Grundlage Ihrer 2D-Daten neu trainiert wird und daraus eine Design-DNA herausfiltert, mit der dann wiederum beliebig viele neue Design-Vorschläge generiert werden können. In der Regel haben Unternehmen, die für diese Art von KI-Optimierung in Frage kommen, bereits eine Fülle an Daten (v.a. 2D-Daten ihrer Produkte), aus denen sie bisher keinen großen Nutzen ziehen. Nutzen Sie also das Potenzial Ihrer Daten und helfen Sie Ihrer Design-Abteilung dabei, repetitive und monotone Arbeitsschritte zu verringern, damit sie sich auf die wesentlichen, kreativen und schöpferischen Arbeiten konzentrieren können.

Sie möchten noch mehr über creaition erfahren? Hier können Sie sich das vollständige Conference-Paper herunterladen, das Marco Limm und seine Co-Autoren (Kevin German, Matthias Wölfel und Silke Helmerdig) für die ArtsIT zu diesem Thema verfasst haben.

Wenn Sie Interesse an einer Zusammenarbeit in diesem Pilotprojekt haben, dann kontaktieren Sie uns gerne über unser Kontaktformular oder schreiben Sie eine Mail an hello@creaition.io.

Der Anfang der Adventszeit brachte dieses Jahr nicht nur den ersten Schnee in der Rhein-Main Region (Abb. 1), sondern leitete auch bei vielen nach einem Jahr voller turbulenter Ereignisse und endlosen Stunden im Homeoffice die alljährliche Zeit der Besinnlichkeit ein. Obgleich sich die angesprochene Besinnung bei vielen eher euphemistisch äußert, in Form von Geschenk- und Planungsstress oder der alljährlichen Jahresendrallye bei STATWORX, dürfen gerne auch Erinnerungen an gutes Essen, kitschige Musik und gemütliche Abende heraufbeschworen werden.

Abb. 1: Schnee in Rhein-Main
Abb. 1: Für einen kurzen Moment scheint der Weltenbrand durch unsere Lieblingsniederschlagsform erloschen, und die Welt wirkt restlos in unschuldiges und reines Weiß getaucht.
Anm. der Redaktion: Der Autor hatte eine schwierige Woche. Nichtsdestotrotz gestehen wir ein, dass seine Worte ein positives Stimmungsbild inspirieren könnten.

Mit dem Advent bricht bekanntlich auch die Zeit der Weihnachtsplätzchen an. Eine exzellente Gelegenheit, bei meinen STATWORX-Kolleg*innen unter dem Vorwand der Nächstenliebe Sympathie und professionelles Ansehen durch unschuldig wirkende, zuckerhaltige Kalorienbomben inklusive Deep-Learning-Kniff zu erlangen. In Ergänzung zu meinem vorangegangenen Artikel zum Thema Kochen mit Deep Learning, möchte ich in diesem Beitrag eine kleine Web-App vorstellen, mit der sich alternative Zutaten für Rezepte vorschlagen lassen, untermalt von KI-generierten Weihnachtsliedern. Ziel dieser Artikel (und anderer, wie zum Beispiel unsere Super Mario spielende KI) ist es, die Grundlagen hinter den oftmals etwas mystisch wirkenden Deep Learning Methoden anschaulich zu vermitteln. In vielen Gesprächen entstand bei uns der Eindruck, dass durch solch einen Überblick spannende Anwendungs- und Geschäftsfälle wesentlich besser erschlossen werden können, indem man sich zunächst bewusst macht, welche grundsätzlichen Anwendungen mittels Deep Learning erschlossen werden können.

Alternative Zutaten für Rezepte finden mittels Word Embeddings

Schon länger dominieren Anwendungen und Publikationen zum Thema Natural Language Processing die Deep Learning Forschung. Regelmäßig ermöglichen bahnbrechende Ergebnisse neue Anwendungsfälle. Eines der Schlagworte war hier zunächst Word Embeddings mittels Word2Vec und nun brandaktuell Transformer-Modelle und ihr Attention-Mechanismus, wie beispielsweise BERT oder GPT-3.

Zur genaueren Veranschaulichung dieser Methode werden im Folgenden zunächst die Grundlagen von Word Embeddings erläutert. Anschließend wird aufgezeigt, wie diese Methode genutzt wurde, um Zutaten in Rezepten durch andere, möglichst ähnlich-verwendete Lebensmittel auszutauschen. Dabei werden nicht einfach „blind“ Vorschläge gemacht sondern aus ähnlichen, kontextuell verwandten Rezepten Vorschläge erkannt und abgeleitet. Somit kann (hoffentlich) sichergestellt werden, dass das alternative Rezept zur kulinarischen Freude wird und nicht unmittelbar im Mülleimer landet.

Grundlagen von Word Embeddings

Word2Vec ist ein ausgezeichnetes Beispiel, um eine der zentralen Konzepte des Deep Learnings zu veranschaulichen: das Representation Learning. Sehr vereinfacht dem Gehirn nachempfunden, durchlaufen Daten auch in künstlichen neuronalen Netzen mehrere Schichten. Jede Schicht verändert und kombiniert die Daten vorhergehender Schichten dahingehend, dass eine dichtere und abstraktere Repräsentation der Daten entsteht. Diese Ansammlungen an Zahlen, die aus menschlicher Sicht keine intuitive Bedeutung mehr haben, enthalten nicht mehr alle Informationen der Ursprungsdaten sondern nur noch jene, die für das Modell zur Lösung der jeweiligen Aufgabe als relevant eingestuft werden. Beim Training der Modelle wird die Repräsentationen also dahingehend optimiert, die Fehler der Modell-Vorhersage zu minimieren.

Möchte man also Word Embeddings nutzen, um Worte hinsichtlich ihrer Bedeutung zu vergleichen oder Ähnlichkeiten zu erkennen, wird ein Deep Learning Modell zum allgemeinen Sprachverständnis trainiert. Dies beinhaltet meistens Aufgaben, wie die Vorhersage benachbarter Worte oder des nächsten Satzes. Um diese Aufgaben lösen zu können, muss das Modell also die grundsätzliche Verwendung von Worten, insb. im Kontext von anderen Worten erlernen. Da man im Falle unserer Word Embeddings aber nur an den internen Repräsentierung der einzelnen Worte interessiert ist, ist dieses Vorgehen (Abb. 2) eigentlich nur Mittel zum Zweck.

Abb.2: Word2Vec Verfahren zur Vorhersage von benachbarten Worten

Beim Word2Vec Verfahren wird im Training versucht, ausgehend vom mittleren Wort die links und rechts benachbarten Worte vorherzusagen. Wichtig ist, dass die Repräsentierung des mittleren Wortes durch das Umfeld bzw. den Kontext geprägt wird. Treten Worte in ähnlichen Kontexten auf, ähnelt sich ihre numerische Repräsentierung. Daraus erwarten wir beispielsweise, dass die Embeddings von Feldsalat und Radicchio sich wesentlich näher sind (häufiger Kontext: Öl, Zwiebeln, Essig, Schüssel…), als die von Feldsalat und Dosenananas (seltener Kontext: trauriger verkaterter Sonntag im Studium).

Anwendung auf ein konkretes Beispiel: Pätzchen-Rezepte mit Bake2Vec

Wie auch im vorangegangenen Artikel zu diesem Beitrag wurden die Embeddings auf einer großen Ansammlung an Texten, genannt Corpus, trainiert. In diesem Fall ca. eine Million Rezepte aus Büchern und vor allem bekannten (englischen) Rezept-Webseiten, wie von der BBC oder Epicurious.

Hierbei prägen zwei verschiedene Kontexte die Embeddings:

  1. Die Auflistung aller Zutaten eines Gerichts
  2. Die Fließtext-Anleitung zur Zubereitung, also die angeleiteten Schritte im Kochrezept selbst

Nach dem Training entsteht eine Datenbank an Wort- und Embedding-Paaren, die mittels bestimmter Metriken verglichen werden können. Für gewöhnlich wird die Kosinus-Ähnlichkeit zwischen den Embeddings berechnet, womit man einen normierten Wert zwischen 0 und 1 enthält, der sozusagen die Güte einer Zutat als Ersatz einer anderen abbildet.  (Abb. 3)

Abb.3: Screenshot Web-App
Abb. 3: Screenshot aus der Web-App zur Recherche von Alternativzutaten

Für jede Zutat lassen sich Alternativen anzeigen. Beurteilen Sie die Vorschläge im Vergleich zu Ihren eigenen Ideen! Auch können Sie die Zutaten im Textfeld ändern/überschreiben, und sich Vorschläge für diese anzeigen lassen. Hier gehts zur Web-App.

Mit Generativen Modellen Weihnachtslieder generieren

Generative Modelle beweisen schon länger, zu welchen eindrucksvollen Resultaten Deep Learning abseits klassischer Machine Learning Anwendungen, wie Klassifikation und Regression, fähig sind. Anwendungsfälle wie das Generieren von fehlenden Datenpunkten oder das Ausfüllen von verdeckten Flächen in Bildern finden in der Geschäftswelt Anwendung. Künstler*innen und Enthusiasten erstellen dagegen Kunstwerke, Gedichte oder Fotos von nicht-existierenden Gesichtern. Vor 2 Jahren erzielte sogar das erste KI-generierte Porträtgemälde über $400.000 bei einer Auktion.

Neben der bildenden Kunst haben generative Modelle auch in der Musikszene ersten Anklang gefunden. Im folgenden Abschnitt betrachten wir die Generierung von Weihnachtsliedern am Beispiel einfacher Jingles und Ausschnitte wie „Oh Tannenbaum oder „Alle Jahre wieder. Damit schaffen wir zum Wohle der Lesenden und Hörenden einen Mariah Carey- und Michael Bublé-freien Safe Space, dem aber leider auch die George Michaels, Crosbys und Sinatras zum Opfer fallen.

Tensorflow Magenta

Das Magenta Projekt möchte „die Rolle von Machine Learning in kreativen Prozessen“ erforschen und bietet dabei eine Vielzahl an Veröffentlichungen, Programmier-Bibliotheken und Tools zur Generierung von Musik. Die Dance-Punk Band YACHT arbeitete daraufhin mit Google zusammen und erstellte einen Katalog aus den MIDI Tonspuren ihrer bisherigen Lieder, die dann einzeln oder gepaart (z.B. Gitarren- und Bass-Riff zusammen) verwendet wurden, um neue Musik im Stil des bisherigen Songs der Band zu generieren. Ähnlich wurde auch mit den Liedtexten verfahren. Selbst das Album Cover und die Videos im Hintergrund der Konzerte wurden mit Deep Learning Modellen generiert und verfeinert.

Die im nächsten Abschnitt beschriebenen Rekurrenten Neuronale Netze bieten eine etablierte Methode im Umgang mit einspurigen Riffs oder Jingles. Verschiedene Ausführungen und Varianten davon sind im „Magenta-Werkzeugkasten“ als MelodyRNN enthalten.

Rekurrente Modelle

Vor der Einführung von Transformer-Modellen wurden im Bereich NLP größtenteils Rekurrente Neuronale Netze (RNNs) verwendet, die von Natur aus besonders geeignet sind, sequenziellen Daten zu verarbeiten. Dies bedeutet, dass Rekurrente Netze es ermöglichen, Entscheidungen oder Vorhersagen bezüglich aufeinander folgender, abhängiger Datenpunkte zu treffen. Hierzu zählen bspw. aufeinanderfolgende Worte in einem Satz, Werte aus Sensoren im Zeitverlauf, oder eben Noten einer Partitur, die im Zeitverlauf betrachtet eine Melodie ergeben. Am Beispiel einer Wortsequenz ist es also wichtig, dass ein Machine Learning Modell einordnen kann, welche Worte in welcher Abfolge im Text erscheinen.

Um diese Informationen aus den Daten ableiten zu können, pflegen RNNs einen internen Zustand, der zusätzlich zur oben beschriebenen Repräsentation nicht nur vom aktuell betrachteten Wort, sondern auch vom internen Zustand des RNNs bei vorherigen Worten abhängt. (Abb. 4)

Abb. 4: RNN
Abb. 4: RNN Beispiel

Das RNN pflegt einen internen Zustand vorangegangener Inputs. Der neue Zustand ergibt sich aus einer Gewichtung des alten Zustands und des aktuellen Inputs.

Als Output wird in diesem Fall versucht, das folgende Wort vorherzusagen. Das RNN sollte erkennen, dass im Kontext des Wortes Weihnachten eher das Wort „backen“ vorhergesagt werden muss, und nicht etwa „kaufen“.

Um ein generatives Modell zu entwickeln, trainiert man das RNN darauf, für eine gegebene Sequenz an Worten stets das nächste, passende Wort vorherzusagen. Wendet man das Modell anschließend an, präsentiert man eben eine solche Sequenz an Worten als vorgegebenen Input, nimmt den vorhergesagten Output des Modells hinzu, füttert diesen als folgenden Input wieder in das Modell und wiederholt diesen Vorgang beliebig oft. So macht das Modell Vorhersagen auf dessen eigene Vorhersagen und generiert somit einen Text.

Musik generieren

Da es sich bei Noten von Volks- und Weihnachtsliedern auch um eine sequenzielle Abfolge von Daten handelt, lässt sich die zuvor beschriebene Methodik anschaulich auf musikalische Daten übertragen.

Möchte man ein Lied in einem bestimmten Stil oder Genre eines anderen Liedes weiterführen oder generieren, kann man im einfachsten Falle ein von Magenta publiziertes (und vortrainiertes) MelodyRNN verwenden. Dort gibt man die gewünschte Anfangsmelodie als MIDI Datei vor und definiert ggf. noch weitere Parameter wie Länge oder Freiheitsgrade in der Generierung. Anschließend wird das Lied, analog zum Text-Beispiel, Ton für Ton synthetisiert.

Abb. 5: Generierte Musik "oh Tannenbaum"
Abb.5: Kein Vivaldi, dafür aber eine Flasche Primitivo; der musikalisch gänzlich untalentierte Autor schafft es eines Nachts, Noten in einspurige MIDI Dateien ohne Taktwechsel zu exportieren, um sie mit Magenta verarbeiten zu können.

Für den interessierten Lesenden gibt es an dieser Stelle noch einiges zu entdecken! Um den Bogen zum Thema Representation Learning zu schlagen, empfehlen wir einen Blick auf MusicVAE [https://magenta.tensorflow.org/music-vae]. Mit einem Variational Autoencoder lassen sich Embeddings (merke: nicht nur auf Worte beschränkt, sondern auch ganze Texte, Bilder, Lieder,…) erlernen, welche einfach und strukturiert manipulierbar sind. Somit lässt sich beispielsweise eine Komponente eines Embeddings ändern, die das Musikgenre darstellt, aber nicht die Melodie. (Re)konstruiert man anschließend das Embedding, erhält man ein Lied mit der gleichen Melodie, jedoch im Stil einer anderen Musikrichtung.

Beispiele für State-of-the-Art Musikgenerierung finden sich auch in der OpenAI Jukebox, welche sich auch eines VAE-Modells bedient.

Fazit

Bei den in diesem Artikel beschriebenen Methoden muss natürlich meist etwas Auslese oder Feinabstimmung betrieben werden, um die gewünschten Ergebnissen zu erzielen. Im Falle der kreativen Anwendung, wie bei der Band YACHT, wurden tausende, wenn nicht zehntausend Melodien generiert und durchsucht, um zufriedenstellende Resultate zu erhalten. Bei den Plätzchenzutaten hingegen ging es eher um die Exploration von Modell-Varianten und -Parametern, welche dann zu beständig guten Ergebnissen führen.

Der Autor hofft, dass Ihnen der kleine Einblick in Methoden des Natural Language Processing gefallen hat und möchte Sie animieren, die Plätzchen Web-App auszuprobieren, oder diese zu missbrauchen, um sich Alternativen zu deftigen Zutaten oder Gemüse auszugeben.

Bleiben Sie so artig, wie nötig! Frohe Weihnachten! J.

Anmerkungen & Quellen

A) Hallo und danke Mama!

Abb. 6: Plaetzchen
Abb. 6: Eine unvollständige Auswahl der Plätzchen der Familie des Autors.

Während mütterlicherseits jährlich über 20 Sorten gebacken werden, schafft es die Tante nur auf mickrige acht. Die Begeisterung und das Interesse am Kochen und Backen ist im Kindesalter bereits auf den Autor übergesprungen. Im Gegenzug jedoch wundert sich dessen Familie des Öfteren, „was dieses Deep Learning denn genau ist“ und was der Junge auf der Arbeit eigentlich macht. Anwendungsbeispiele wie diese Web-App sind dabei wunderbare Gelegenheiten, Methoden des Deep Learning anschaulich zu erklären, Alltagsbezug zu schaffen und sich für die vielen kommenden fachlichen Herausforderungen zu motivieren!

B) Die Rezepte dieser kleinen Exkursion wurden Chefkoch.de entnommen, zu den Originalen gelangen Sie über die folgenden Links:

 

Jonas Braun Jonas Braun

Management Summary

In modernen Unternehmen fallen im Tagesgeschäft an vielen Stellen Informationen in Textform an: Je nach Businesskontext können dies Rechnungen sein, oder auch Emails, Kundeneingaben (wie Rezensionen oder Anfragen), Produktbeschreibungen, Erklärungen, FAQs sowie Bewerbungen. Diese Informationsquellen blieben bis vor kurzem weitestgehend dem Menschen vorbehalten, da das maschinelle, inhaltliche Verstehen von Text ein technologisch herausforderndes Problem darstellt.
Aufgrund jüngster Errungenschaften im Bereich Deep Learning können nun eine Reihe unterschiedlicher NLP („Natural Language Processing“) Tasks mit erstaunlicher Güte gelöst werden.
Erfahren Sie in diesem Beitrag anhand von fünf praxisnahen Beispielen, wie NLP Use Cases diverse Businessprobleme lösen und so für Effizienz und Innovation sorgen.

Einführung

Natural Language Processing (NLP) ist zweifelslos ein Gebiet, dem in jüngster Vergangenheit besondere Aufmerksamkeit im Big Data-Umfeld zugekommen ist. So hat sich das von Google gemessene Interesse an dem Thema in den letzten drei Jahren mehr als verdoppelt. Daran ist erkennbar, dass innovative NLP-Technologien längst nicht mehr nur ein Thema für die Big Player, wie Apple, Google oder Amazon, ist. Vielmehr ist eine generelle Demokratisierung der Technologie zu beobachten. Einer der Gründe dafür ist sicherlich, dass nach einer Schätzung von IBM etwa 80% der „weltweiten Informationen“ nicht in strukturierten Datenbanken vorliegen, sondern in unstrukturierter, natürlicher Sprache. NLP wird zukünftig eine Schlüsselrolle einnehmen, wenn es darum geht, diese Informationen nutzbar zu machen. Damit wird der erfolgreiche Einsatz von NLP-Technologien zu einem der Erfolgsfaktoren für die Digitalisierung in Unternehmen werden.

Damit Sie sich ein Bild davon machen können, welche Möglichkeiten NLP heutzutage im Businesskontext öffnet, werden Ihnen im Folgenden fünf praxisnahe Anwendungsfälle vorgestellt und die dahinterstehende Lösungen erklärt.

Was ist NLP? – Ein kurzer Überblick

Als ein Forschungsthema, das bereits in den 50er Jahren Linguisten und Informatiker beschäftigte, fristete NLP im 20sten Jahrhundert auf der Anwendungsseite ein kaum sichtbares Dasein.

Der zentrale Grund dafür lag in der Verfügbarkeit der notwendigen Trainingsdaten. Zwar ist generell die Verfügbarkeit von unstrukturierten Daten, in Form von Texten, insbesondere mit dem Aufstieg des Internets exponentiell gestiegen, jedoch fehlte es weiterhin an geeigneten Daten für das Modelltraining. Dies lässt sich damit begründen, dass die frühen NLP Modelle zumeist überwacht trainiert werden mussten (sogenanntes Supervised Learning). Das Supervised Learning setzt jedoch voraus, dass Trainingsdaten mit einer dedizierten Zielvariable versehen werden müssen. Dies bedeutet, dass z.B. bei einer Textklassifikation der Textkorpus vor dem Modelltraining manuell durch Menschen annotiert werden muss.

Dies änderte sich Ende der 2010er Jahre, als eine neue Modellgeneration künstlicher neuronaler Netzwerke zu einem Paradigmenwechsel führte. Diese sogenannten „Language Models“ werden auf Grundlage riesiger Textkorpora von Facebook, Google und Co. (vor-)trainiert, indem einzelne Wörter in den Texten zufällig maskiert und im Verlauf des Trainings vorhergesagt werden. Es handelt sich dabei um das sogenannte selbstüberwachte Lernen (Self-Supervised Learning), das nicht länger eine separate Zielvariable voraussetzt. Im Zuge des Trainings erlernen diese Modelle ein kontextuelles Verständnis von Texten.

Vorteil dieses Vorgehens ist, dass ein- und dasselbe Modell mit Hilfe des erlernten kontextuellen Verständnisses für eine Vielzahl unterschiedlicher Downstream-Tasks (z.B. Textklassifizierung, Sentiment Analysis, Named Entity Recognition) nachjustiert werden kann. Dieser Vorgang wird als Transfer Learning bezeichnet. In der Praxis lassen sich diese vortrainierten Modelle herunterladen, sodass nur die Feinjustierung für die spezifische Anwendung durch zusätzliche Daten selbst gemacht werden muss. Folglich lassen sich mittlerweile mit wenig Entwicklungsaufwand performante NLP-Anwendungen entwickeln.

Um mehr über Language Models (insbesondere die sogenannten Transformer Modelle wie „BERT“, bzw. „roBERTa“, u.ä.) sowie Trends und Hemmnisse im Bereich NLP zu erfahren, lesen Sie hier den Beitrag zum Thema NLP-Trends von unserem Kollegen Dominique Lade.

Die 5 Use Cases

Textklassifizierung im Rekrutierungsprozess

Ein medizinisches Forschungsinstitut möchte seinen Rekrutierungsprozess von Studienteilnehmer*innen effizienter gestalten.

Für das Testen eines neuen Medikaments werden unterschiedliche, untereinander abhängige Anforderungen an die infrage kommende Personen gestellt (z.B. Alter, allg. Gesundheitszustand, Vorhandensein/Abwesenheit von Vorerkrankungen, Medikationen, genetische Dispositionen etc.). Das Prüfen all dieser Anforderungen ist mit einem großen Zeitaufwand verbunden. Üblicherweise dauert das Sichten und Beurteilen relevanter Informationen etwa eine Stunde pro potenziellen Studienteilnehmenden. Hauptgrund dafür ist, dass die klinischen Notizen Informationen über Patienten enthalten, die über strukturierte Daten wie Laborwerte und Medikamente hinausgehen: Auch unstrukturierter Informationen sind in den medizinischen Berichten, Arztbriefen, und Entlassungsberichten o.ä. in Textform zu finden. Insbesondere das Auswerten letzterer Daten bedarf viel Lesezeit und ist daher mit großem Aufwand verbunden. Um den Prozess zu beschleunigen, entwickelt das Forschungsinstitut ein Machine Learning Modell, das eine Vorauswahl von vielversprechenden Kandidaten trifft, sodass die Experten*innen lediglich die vorgeschlagene Personengruppe validieren müssen.

Die NLP Lösung

Aus methodischer Sicht handelt es sich bei diesem Problem um eine sogenannte Textklassifikation. Dabei wird basierend auf einem Text, eine Prognose für eine zuvor definierte Zielvariable erstellt. Um das Modell zu trainieren, ist es – wie im Supervised Learning üblich – notwendig, die Daten, in diesem Fall also die Arztdokumente, mit der Zielvariable zu annotieren. Da es hier ein Klassifikationsproblem zu lösen gilt (geeignete oder ungeeignete Studienteilnehmer*in), beurteilen die Experten*innen für einige Personen im Pool die Eignung für die Studie manuell. Ist eine Person geeignet, wird sie mit einer Eins gekennzeichnet (=positiver Fall), ansonsten mit einer Null (=negativer Fall). Anhand dieser Trainingsbeispiele kann das Modell nun Zusammenhänge zwischen den medizinischen Dokumenten der Personen und ihrer Eignung lernen.

Um der Komplexität des Problems Herr zu werden, wird ein entsprechend komplexes Modell namens ClinicalBERT verwendet. Dabei handelt es sich um ein Language Modell, das auf BERT (Bidirectional Encoder Representations from Transformers) basiert, und zusätzlich auf einem Datensatz von klinischen Texten trainiert wurde. Somit ist ClinicalBERT in der Lage, sogenannte Repräsentationen von sämtlichen medizinischen Dokumentationen für jede Person zu generieren. In einem letzten Schritt wird das neuronale Netzwerk von ClinicalBERT durch eine taskspezifische Komponente ergänzt. In diesem Fall handelt es sich um eine binäre Klassifikation: Zu jeder Person soll eine Eignungswahrscheinlichkeit ausgegeben werden. Durch einen entsprechenden linearen Layer wird die hochdimensionale Textdokumentation schlussendlich in eine einzige Zahl, die Eignungswahrscheinlichkeit, überführt. In einem Gradientenverfahren lernt das Modell nun anhand der Trainingsbeispiele die Eignungswahrscheinlichkeiten.

Weitere Anwendungsszenarien von Textklassifikation

Textklassifikation findet häufig in der Form von Sentiment Analysis statt. Dabei geht es darum, Texte in vordefinierte Gefühlskategorien (z.B. negativ/positiv) einzuordnen. Diese Informationen sind insbesondere in der Finanzwelt oder beim Social Media Monitoring wichtig. Darüber hinaus kann Textklassifikation in verschiedenen Kontexten verwendet werden, in denen es darum geht, Dokumente nach ihrem Typ zu sortieren (z.B. Rechnungen, Briefe, Mahnungen…).

Named Entity Recognition zur Verbesserung der Usability einer Nachrichtenseite

Ein Verlagshaus bietet seinen Leser*innen auf einer Nachrichtenseite eine Vielzahl von Artikeln über diverse Themen an. Im Zuge von Optimierungsmaßnahmen möchte man ein besseres Recommender-System implementieren, sodass zu jedem Artikel weitere passende (ergänzende oder ähnliche) Artikel vorgeschlagen werden. Außerdem möchte man die Suchfunktion auf der Landingpage verbessern, damit der Kunde oder die Kundin schnell den Artikel findet, der gesucht ist.
Um für diese Zwecke eine gute Datengrundlage zu schaffen, entscheidet sich der Verlag dazu, mit Named Entity Recognition den Texten automatisierte Tags zuzuordnen, anhand derer sowohl das Recommender-System als auch die Suchfunktion verbessert werden können. Nach erfolgreicher Implementierung wird auf deutlich mehr vorgeschlagene Artikel geklickt und die Suchfunktion ist wesentlich komfortabler geworden. Im Resultat verbringen die Leser*innen signifikant mehr Zeit auf der Seite.

Die NLP Lösung

Um das Problem zu lösen, ist es wichtig, die Funktionsweise von NER zu verstehen:

Bei NER geht es darum, Worte oder ganze Satzglieder inhaltlichen Kategorien zuzuordnen. So kann man „Peter“ beispielsweise als Person identifizieren, „Frankfurt am Main“ ist ein Ort und „24.12.2020“ ist eine Zeitangabe. Offensichtlich gibt es aber auch deutlich kompliziertere Fälle. Dazu vergleichen Sie die folgenden Satzpaare:

  1. „Früher spazierte Emma im Park immer an der schönen Bank aus Holz vorbei.“   (Bank = Sitzbank)
  2. „Gestern eilte sie noch zur Bank, um das nötige Bargeld abzuheben.“ (Bank = Geldinstitut)

Für den Menschen ist vollkommen offensichtlich, dass das Wort „Bank“ in den beiden Sätzen eine jeweils andere Bedeutungen hat. Diese scheinbar einfache Unterscheidung ist für den Computer allerdings alles andere als trivial. Ein Entity Recognition Modell könnte die beiden Sätze wie folgt kennzeichnen:

  1. „[Früher] (Zeitangabe) spazierte [Emma] (Person) im Park immer an der schönen [Bank] (Sitzgelegenheit) aus Holz vorbei.“
  2. „[Gestern] (Zeitangabe) eilte [sie] (Person/Pronomen) noch zur [Bank] (Geldinstitut), um das nötige Bargeld abzuheben.“  

In der Vergangenheit hätte man zur Lösung des obigen NER-Problems zu regelbasierten Algorithmen gegriffen, doch auch hier setzt sich der Machine Learning Ansatz durch:

Das vorliegende Multiclass-Klassifizierungsproblem der Entitätsbestimmung wird erneut mithilfe des BERT-Modells angegangen. Zusätzlich wird das Modell auf einem annotierten Datensatz trainiert, in dem die Entitäten manuell identifiziert sind. Die umfangreichste öffentlich zugängliche Datenbank in englischer Sprache ist die Groningen Meaning Bank (GMB). Nach erfolgreichem Training ist das Modell in der Lage, aus dem Kontext, der sich aus dem Satz ergibt, auch bisher unbekannte Wörter korrekt zu bestimmen. So erkennt das Modell, dass nach Präpositionen wie „in, bei, nach…“ ein Ort folgt, aber auch komplexere Kontexte werden in Bezug auf die Entitätsbestimmung herangezogen.

Weitere Anwendungsszenarien von NER:

NER ist als klassische Information Retrieval-Task für viele andere NER-Tasks, wie zum Beispiel Chatbots und Frage-Antwort Systeme, zentral. Darüber hinaus wird NER häufig zur Textkatalogisierung verwendet, bei der der Typ des Textes anhand von stichhaltigen, erkannten Entitäten bestimmt wird.

Ein Chatbot für ein Fernbusunternehmen

Ein Fernbusunternehmen möchte seine Erreichbarkeit erhöhen und darum die Kommunikationswege mit dem Kunden ausbauen. Neben seiner Homepage und seiner App möchte das Unternehmen einen dritten Weg zum Kunden, nämlich einen Whatsapp-Chatbot, anbieten. Die Zielvorstellung ist, dass man in der Konversation mit dem Chatbot gewisse Aktionen wie das Suchen, Buchen und Stornieren von Fahrten ausführen kann. Außerdem soll mit dem Chatbot ein zuverlässiger Weg geschaffen werden, die Fahrgäste über Verspätungen zu informieren.

Mit der Einführung des Chatbots können nicht nur bestehende Fahrgäste leichter erreicht werden, sondern auch Kontakt zu neuen Kunden*innen aufgebaut werden, die noch keine App installiert haben.

Die NLP Lösung

Abhängig von den Anforderungen, die an den Chatbot gestellten werden, wählt man zwischen verschiedenen Chatbot Architekturen aus.

Über die Jahre sind im Wesentlichen vier Chatbot-Paradigmen erprobt worden: In einer ersten Generation wurde die Anfrage auf bekannte Muster geprüft und entsprechend angepasste vorgefertigte Antworten ausgegeben („pattern matching“). Etwas ausgefeilter ist das sogenannte „grounding“, bei der durch Named Entity Recognition (s.o.) aus Wissensbibliotheken (z.B. Wikipedia) extrahierte Informationen in einem Netzwerk organisiert werden. Ein solches Netzwerk hat den Vorteil, dass nicht nur eingetragenes Wissen abgerufen werden kann, sondern, dass auch nicht registriertes Wissen durch die Netzwerkstruktur inferiert werden kann. Beim „searching“ werden direkt Fragen-Antwortpaare aus dem Konversationsverlauf (oder aus davor registrierten Logs) zum Suchen einer passenden Antwort herangezogen. Die Anwendung von Machine Learning Modellen ist der bewährteste Ansatz, um dynamisch passende Antworten zu generieren („generative models“).

Um einen modernen Chatbot mit klar eingrenzbaren Kompetenzen für das Fernbusunternehmen zu implementieren, empfiehlt es sich, auf bestehende Frameworks wie Google Dialogflow zurückzugreifen. Hierbei handelt es sich um eine Plattform, mit der sich Chatbots konfigurieren lassen, die die Elemente aller zuvor gennannten Chatbot-Paradigmen besitzen. Dazu übergibt man Parameter wie Intends, Entitäten und Actions.

Ein Intend („Benutzerabsicht“) ist beispielsweise die Fahrplanauskunft. Indem man verschiedene Beispielphrasen („Wie komme ich am … von … nach … “, „Wann fährt der nächste Bus von … nach …“) an ein Language Model übergibt, gelingt es dem Chatbot auch ungesehene Inputsätze dem richtigen Intend zuzuordnen (vgl. Textklassifikation).

Weiterhin werden die verschiedenen Reiseorte und Zeitangaben als Entitäten definiert. Wird nun vom Chatbot ein Intend mit passenden Entitäten erfasst (vgl. NER), dann kann eine Action, in diesem Fall eine Datenbankabfrage, ausgelöst werden. Schlussendlich wird eine Intend-Answer mit den relevanten Informationen ausgegeben, die an sämtliche vom Benutzer angegebene Informationen im Chatverlauf angepasst ist („stateful“).

Weitere Anwendungsszenarien von Chatbots:

Es gibt vielfältige Einsatzmöglichkeiten im Kundenservice – je nach Komplexität des Szenarios von der automatischen Vorbereitung (z.B. Sortierung) eines Kundenauftrags hin zur kompletten Abwicklung einer Kundenerfahrung.

Ein Question-Answering-System als Voice Assistant für technische Fragen zum Automobil

 Ein Automobilhersteller stellt fest, dass viele seiner Kunden*innen nicht gut mit den Handbüchern, die den Autos beiliegt, zurechtkommt. Häufig wird zu lange nach der relevanten Information gesucht oder sie wird gar nicht gefunden. Daher wird beschlossen, ergänzend zum statischen Handbuch auch einen Voice Assistant anzubieten, der auf technische Fragen präzise Antworten gibt. Zukünftig können die Fahrer*innen bequem mit ihrer Mittelkonsole sprechen, wenn sie ihr Fahrzeug warten wollen oder technische Auskunft wünschen.

Die NLP Lösung

Mit Frage-Antwort-Systemen wird sich schon seit Jahrzehnten auseinandergesetzt wird, stehen sie doch in gewisser Hinsicht an der Vorfront der künstlichen Intelligenz. Ein Frage-Antwort-System, das unter Berücksichtigung aller vorliegenden Daten immer eine korrekte Antwort fände, könnte man auch als „General AI“ bezeichnen. Eine Hauptschwierigkeit auf dem Weg zur General AI ist, dass das Gebiet, über das das System informiert sein muss, unbegrenzt ist. Demgegenüber liefern Frage-Antwort-Systeme gute Ergebnisse, wenn das Gebiet klar eingegrenzt ist, wie es beim Automobilassistenten der Fall ist. Grundsätzlich gilt: Je spezifischer das Gebiet, desto bessere Ergebnisse können erwartet werden.

Für die Implementierung des Frage-Antwort-Systems werden strukturierte Daten, wie technische Spezifikationen der Komponenten und Kennzahlen des Modells, aber auch unstrukturierte Daten, wie Handlungsanweisungen, aus dem Handbuch herangezogen. Sämtliche Daten werden in einem Vorbereitungsschritt mithilfe anderer NLP-Techniken (Klassifikation, NER) in Frage-Antwort-Form gebracht. Diese Daten werden einer Version von BERT übergeben, die bereits auf einem großen Frage-Antwort-Datensatz („SQuAD“) vortrainiert wurde. Das Modell ist damit in der Lage, souverän bereits eingespeiste Fragen zu beantworten, aber auch „educated guesses“ für ungesehene Fragen abzugeben.

Weitere Anwendungsszenarien von Frage-Antwort-Systemen:

Mithilfe von Frage-Antwort-Systemen können unternehmensinterne Suchmaschinen um Funktionalitäten erweitert werden. Im E-Commerce können auf Basis von Artikelbeschreibungen und Rezensionen automatisiert Antworten auf Sachfragen gegeben werden.

Automatische Textzusammenfassungen (Textgenerierung) von Schadensbeschreibungen für eine Sachversicherung

Eine Versicherung möchte die Effizienz ihrer Schadensregulierungsabteilung erhöhen. Es wurde festgestellt, dass es bei einigen Schadensreklamationen vom Kunden zu internen Zuständigkeitskonflikten kommt. Grund dafür ist, dass diese Schäden von Kund*innen zumeist über mehrere Seiten beschrieben werden und so eine erhöhte Einarbeitungszeit benötigt wird, um beurteilen zu können, ob man den Fall bearbeiten soll. So passiert es häufig, dass eine Schadensbeschreibung komplett gelesen werden muss, um zu verstehen, dass man den Schaden selbst nicht zu bearbeiten hat. Nun soll ein System Abhilfe schaffen, das automatisierte Zusammenfassungen generiert. Die Sachbearbeiter*innen können in Folge der Implementierung nun deutlich schneller über die Zuständigkeit entscheiden.

Die NLP Lösung

Grundsätzlich kann man beim Probelm der Textzusammenfassung zwischen zwei verschiedenen Ansätzen differenzieren: Bei der Extraction werden aus dem Inputtext die wichtigsten Sätze identifiziert, die dann im einfachsten Fall als Zusammenfassung verwendet werden. Dem gegenüber steht die Abstraction, bei der ein Text durch ein Modell in einen neu generierten Zusammenfassungstext überführt wird. Der zweite Ansatz ist deutlich komplexer, da hier Paraphrasierung, Generalisierung oder das Einbeziehen von weiterführendem Wissen möglich ist. Daher birgt dieser Ansatz auch ein größeres Potenzial, sinnvolle Zusammenfassungen generieren zu können, ist allerdings auch fehleranfälliger. Moderne Algorithmen zur Textzusammenfassung verfolgen den zweiten Ansatz, oder aber eine Kombination aus beiden Ansätzen.

Zur Lösung des Versicherungs-Use-Cases wird ein sogenanntes Sequence-to-Sequence-Modell verwendet, welches einer Wortsequenz (der Schadensbeschreibung) einer anderen Wortsequenz (der Zusammenfassung) zuordnet. Hierbei handelt es sich üblicherweise um ein rekurrentes neuronales Netzwerk (RNN), das auf Grundlage von Textzusammenfassungs-Paaren trainiert wird. Der Trainingsprozess ist so gestaltet, dass die Wahrscheinlichkeit für das nächste Wort abhängig von den letzten Worten (und zusätzlich einem „inner state“ des Modells), modelliert wird. Gleichsam schreibt das Modell effektiv die Zusammenfassung „von links nach rechts“, indem sukzessiv das nächste Wort vorhergesagt wird. Ein alternativer Ansatz sieht vor, den Input vom Language Model BERT numerisch encodieren zu lassen und auf Basis dieser Zahlenrepräsentation einen GPT-Decoder den Text autoregressiv zusammenfassen zu lassen. Mithilfe von Modellparametern kann in beiden Fällen angepasst werden, wie lang die Zusammenfassung etwa sein soll.

Weitere Anwendungsszenarien von Sprachgenerierung:

Ein solches Szenario ist an vielen Stellen denkbar: Das automatisierte Schreiben von Berichten, die Generierung von Texten auf der Grundlage der Analyse von Einzelhandelsverkaufsdaten, die Zusammenfassung von elektronischen Krankenakten oder die Erstellung von textlichen Wettervorhersagen aus Wetterdaten sind denkbare Anwendungen. Darüber hinaus kommt es auch bei anderen NLP Anwendungsfällen wie Chatbots und Q&A-Systemen zur Sprachgenerierung.

Ausblick

Vielleicht haben Sie beim Durchlesen dieser Anwendungsbeispiele von Textklassifikation, Chatbots, Frage-Antwort-Systemen, NER und Textzusammenfassungen den Eindruck gewonnen, dass es auch in Ihrem Unternehmen viele Prozesse gibt, die sich mit NLP-Lösungen beschleunigen ließen.

Tatsächlich ist NLP nicht nur ein spannendes Forschungsfeld, sondern auch eine Technologie, deren Anwendbarkeit im Businessumfeld stetig wächst.

NLP wird in Zukunft nicht nur ein Fundament einer datengetriebenen Unternehmenskultur werden, sondern birgt schon jetzt durch direkte Anwendung ein riesiges Innovationspotenzial, in das es sich zu investieren lohnt.

Bei STATWORX haben wir bereits jahrelange Erfahrung in der Entwicklung von maßgeschneiderten NLP-Lösungen. Hier finden die zwei unserer Case Studies zum Thema NLP: Social Media Recruiting mit NLP & Supplier Recommendation Tool. Wir stehen Ihnen gerne für eine individuelle Beratung zu diesem und vielen weiteren Themen zur Verfügung.

 

Felix Plagge Felix Plagge

Computer sehen zu lassen, dies mag für viele nach Science-Fiction klingen. Denn mit «sehen» ist nicht das Filmen mit einer Webcam, sondern das Verständnis von Bildmaterial gemeint. Tatsächlich sind derartige Technologien hinter den Kulissen vieler alltäglicher Services schon lange im Einsatz. Soziale Netzwerke erkennen seit Jahren Freunde und Bekannte auf Fotos und moderne Smartphones lassen sich mit dem Gesicht anstatt einem PIN-Code entsperren. Neben diesen kleinen Alltagserleichterungen birgt das rasant wachsende Feld der «Computer Vision» weitaus größeres Potenzial für den industriellen Einsatz. Die spezialisierte Verarbeitung von Bildmaterial verspricht sowohl viele repetitive Prozesse zu erleichtern und automatisieren. Zudem sollen Experten und Fachpersonal entlastet und in ihren Entscheidungen unterstützt werden.

Die Grundlagen für Bilderkennung und Computer Vision wurden bereits in den 1970er Jahren geschaffen. Allerdings hat das Feld erst in den letzten Jahren vermehrt Anwendung außerhalb der Forschung gefunden. In unserer Tätigkeit als Data Science & AI Beratung hier bei STATWORX haben wir bereits einige interessante Anwendungsfälle von Computer Vision kennengelernt. Dieser Beitrag stellt fünf ausgewählte und besonders vielversprechende Use Cases verschiedener Industrien vor, die entweder bereits in Produktion anzutreffen sind, oder in den kommenden Jahren große Veränderungen in ihren jeweiligen Feldern versprechen.

Use Cases Computer Vision

1. Einzelhandel: Customer Behavior Tracking

Onlineshops wie Amazon können sich die Analysefähigkeit ihrer digitalen Plattform schon lange zunutze machen. Das Verhalten der Kundschaft kann detailliert analysiert und die User Experience dadurch optimiert werden. Auch die Retailbranche versucht die Erfahrung ihrer Kundschaft zu optimieren und ideal zu gestalten. Allerdings haben bisher die Tools gefehlt, um Interaktion von Personen mit ausgestellten Gegenständen automatisch zu erfassen. Computer Vision vermag diese Lücke für den Einzelhandel nun ein Stück weit zu schließen.

In Kombination mit bestehenden Sicherheitskameras können Algorithmen Videomaterial automatisch auswerten und somit das Kundschaftsverhalten innerhalb des Ladens studieren. Beispielsweise kann die aktuelle Anzahl an Personen im Laden jederzeit gezählt werden, was sich zu Zeiten der COVID-19 Pandemie mit den Auflagen zur maximal erlaubten Anzahl an Besuchern in Geschäften als Anwendungsgebiet anbietet. Interessanter dürften aber Analysen auf der Individualebene sein, wie die gewählte Route durch das Geschäft und einzelne Abteilungen. Damit lassen sich das Design, der Aufbau und die Platzierung von Produkten optimieren, Staus in gut besuchten Abteilungen vermeiden und insgesamt die User Experience der Kundschaft verbessern. Revolutionär ist die Möglichkeit zum Tracking der Aufmerksamkeit, welche einzelne Regale und Produkte von der Kundschaft erhalten. Spezialisierte Algorithmen sind dazu in der Lage, die Blickrichtung von Menschen zu erfassen und somit zu messen, wie lange ein beliebiges Objekt von Passanten betrachtet wird.

Mithilfe dieser Technologie hat der Einzelhandel nun die Möglichkeit zum Onlinehandel aufzuschließen und das Kundschaftsverhalten innerhalb ihrer Geschäfte detailliert auszuwerten. Dies ermöglicht nicht nur die Steigerung von Absätzen, sondern auch die Minimierung der Aufenthaltszeit und optimierte Verteilung von Kunden innerhalb der Ladenfläche.


Abbildung 1: Customer Behavior Tracking mit Computer Vision
(https://www.youtube.com/watch?v=jiaNA1hln5I)

2. Landwirtschaft: Erkennung von Weizenrost mittels Computer Vision

Moderne Technologien ermöglichen Landwirtschaftsbetrieben die effiziente Bestellung immer größerer Felder. Dies hat gleichzeitig zur Folge, dass diese Flächen auf Schädlinge und Pflanzenkrankheiten überprüfen müssen, denn falls übersehen, können Pflanzenkrankheiten zu schmerzhaften Ernteeinbrüchen und Verlusten führen.

Machine Learning verschafft hier Abhilfe, denn mittels des Einsatzes von Drohnen, Satellitenbildern und Remote-Sensoren können große Datenmengen generiert werden. Moderne Technologie erleichtert die Erhebung unterschiedlicher Messwerte, Parameter und Statistiken, welche automatisiert überwacht werden können. Landwirtschaftsbetriebe haben somit rund um die Uhr einen Überblick über die Bodenbedingungen, Bewässerungsgrad, Pflanzengesundheit und lokalen Temperaturen, trotz der großflächigen Bepflanzung von stetig größeren Feldern. Machine Learning Algorithmen werten diese Daten aus. So kann der Landwirtschaftbetrieb frühzeitig anhand dieser Informationen auf potenzielle Problemherde reagieren und vorhandene Ressourcen effizient verteilen kann.

Computer Vision ist für die Landwirtschaft besonders interessant, denn durch die Analyse von Bildmaterial lassen sich Pflanzenkrankheiten bereits im Anfangsstadium erkennen. Vor wenigen Jahren wurden Pflanzenkrankheiten häufig erst dann erkannt wurden, wenn sie sich bereits ausbreiten konnten. Basierend auf Computer Vision lässt sich die großflächige Ausbreitung mittels Frühwarnsysteme nun frühzeitig erkennen und stoppen. Landwirtschaftsbetriebe verlieren dadurch nicht nur weniger Ernte, sie sparen auch beim Einsatz von Gegenmaßnahmen wie Pestiziden, da vergleichsweise kleinere Flächen behandelt werden müssen.

Besonders die automatisierte Erkennung von Weizenrost hat innerhalb der Computer Vision Community viel Aufmerksamkeit erhalten. Verschiedene Vertreter dieses aggressiven Pilzes befallen Getreide in Ostafrika, rund ums Mittelmeer, wie auch in Zentraleuropa und führen zu großen Ernteausfällen von Weizen. Da der Schädling an Stängeln und Blättern von Getreide gut sichtbar ist, lässt er sich von trainierten Bilderkennungsalgorithmen schon früh erkennen und an der weiteren Ausbreitung hindern.


Abbildung 2: Erkennung von Weizenrost mit Computer Vision
(https://www.kdnuggets.com/2020/06/crop-disease-detection-computer-vision.html)

3. Gesundheitswesen: Bildsegmentierung von Scans

Das Potenzial von Computer Vision im Gesundheitswesen ist riesig, die möglichen Anwendungen zahllos. Die medizinische Diagnostik verlässt sich stark auf das Studium von Bildern, Scans und Fotografien. Die Analyse von Ultraschallbildern, MRI- und CT-Scans gehören zum Standardrepertoire der modernen Medizin. Computer Vision Technologien versprechen diesen Prozess nicht nur zu vereinfachen, sondern auch Fehldiagnosen vorzubeugen und entstehende Behandlungskosten zu senken. Computer Vision soll dabei medizinisches Fachpersonal nicht ersetzen, sondern deren Arbeit erleichtern und bei Entscheidungen unterstützen. Bildsegmentierung hilft bei der Diagnostik, indem relevante Bereiche auf 2D- oder 3D Scans erkannt und eingefärbt werden können, um das Studium von Schwarz-Weiß-Bildern zu erleichtern.

Der neuste Use Case für diese Technologie liefert die COVID-19 Pandemie. Bildsegmentierung kann Ärzt*innen und Wissenschaftler*innen bei der Identifikation von COVID-19 und der Analyse und Quantifizierung der Ansteckung und des Krankheitsverlaufs unterstützen. Der trainierte Bilderkennungsalgorithmus identifiziert verdächtige Stellen auf CT-Scans der Lunge. Anschließend ermittelt er deren Größe und Volumen, sodass der Krankheitsverlauf betroffener Patienten klar verfolgt werden kann.

Der Nutzen für das Monitoring einer neuen Krankheit ist riesig. Computer Vision erleichtert Ärzt*innen nicht nur die Diagnose der Krankheit und Überwachung während der Therapie. Die Technologie generiert auch wertvolle Daten zum Studium der Krankheit und ihrem Verlauf. Dabei profitiert auch die Forschung von den erhobenen Daten und dem erstellten Bildmaterial, sodass mehr Zeit für Experimente und Teste anstatt der Datenerhebung verwendet werden kann.

4. Automobil Industrie: Objekterkennung und -klassifizierung im Verkehr

Selbstfahrende Autos gehören definitiv zu den Use Cases aus dem Bereich der künstlichen Intelligenz, denen in letzten Jahren medial am meisten Aufmerksamkeit gewidmet wurde. Zu erklären ist dies wohl eher mit dem futuristischen Anstrich der Idee von autonomem Fahren als den tatsächlichen Konsequenzen der Technologie. Im Grunde genommen sind darin mehrere Machine Learning Probleme verpackt, Computer Vision bildet aber ein wichtiges Kernstück bei deren Lösung.

So muss der Algorithmus (der sogenannte «Agent»), von dem das Auto gesteuert wird, jederzeit über die Umgebung des Autos aufgeklärt sein. Der Agent muss wissen wie die Straße verläuft, wo sich andere Autos in der Nähe befinden, wie groß der Abstand zu potenziellen Hindernissen und Objekten ist und wie schnell sich diese Objekte auf der Straße bewegen, um sich konstant der sich stets ändernden Umwelt anpassen zu können. Dazu sind autonome Fahrzeuge mit umfangreichen Kameras ausgestattet, welche ihre Umgebung flächendeckend filmen. Das erstellte Filmmaterial wird anschließend in Echtzeit von einem Bilderkennungsalgorithmus überwacht. Ähnlich wie beim Customer Behavior Tracking setzt dies voraus, dass der Algorithmus nicht nur statische Bilder, sondern einen konstanten Fluss an Bildern nach relevanten Objekten absuchen und diese klassifizieren kann.


Abbildung 5: Objekterkennung und Klassifizierung im Straßenverkehr (https://miro.medium.com/max/1000/1*Ivhk4q4u8gCvsX7sFy3FsQ.png)

Diese Technologie existiert bereits und kommt auch industriell zum Einsatz. Die Problematik im Straßenverkehr stammt von dessen Komplexität, Volatilität und der Schwierigkeit, einen Algorithmus so zu trainieren, dass auch etwaiges Versagen des Agenten in komplexen Ausnahmesituationen ausgeschlossen werden kann. Dabei entblößt sich die Achillessehne von Computer Vision: Der Bedarf nach großen Mengen an Trainigsdaten, deren Generierung im Straßenverkehr mit hohen Kosten verbunden ist.

5. Fitness: Human Pose Estimation

Die Fitnessbranche befindet sich seit Jahren im Prozess der digitalen Transformation. Neue Trainingsprogramme und Trends werden via YouTube einem Millionenpublikum vorgestellt, Trainingsfortschritte werden mit Apps verfolgt und ausgewertet und spätestens seit dem Beginn der Coronakrise erfreuen sich virtuelle Trainings und Home Workouts massiver Beliebtheit. Gerade beim Kraftsport lassen sich Fitnesstrainer*innen aufgrund der hohen Verletzungsgefahr nicht aus dem Studio wegdenken – noch nicht. Denn während heute das Überprüfen der eigenen Haltung und Position beim Training via Video bereits gängig ist, ermöglicht es Computer Vision auch in diesem Feld Videomaterial genauer als das menschliche Auge auszuwerten und zu beurteilen.

Zum Einsatz kommt dabei eine Technologie, die dem bereits vorgestellten Attention Tracking der Einzelhandelsbranche ähnelt. Human Pose Estimation ermöglicht einem Algorithmus das Erkennen und Schätzen der Haltung und Pose von Menschen auf Video. Dazu wird die Position der Gelenke und deren Stellung im Bezug zueinander ermittelt. Da der Algorithmus gelernt hat, wie die ideale und sichere Ausführung einer Fitnessübung aussehen soll, lassen sich Abweichungen davon automatisiert erkennen und hervorheben. Implementiert in einer Smartphone App kann dies in Echtzeit und mit unmittelbarem Warnsignal geschehen. Somit kann rechtzeitig vor gefährlichen Fehlern gewarnt werden, anstatt Bewegungen erst im Nachhinein zu analysieren. Dies verspricht das Verletzungsrisiko beim Krafttraining maßgeblich zu reduzieren. Training ohne Fitnesstrainer*innen wird dadurch sicherer und die Kosten für sicheres Krafttraining werden gesenkt.

Human Pose Estimation ist ein weiterer Schritt in Richtung digitalem Fitnesstraining. Smartphones sind im Fitnesstraining bereits weitgehend etabliert. Apps, die das Training sicherer machen, dürften bei der breiten Nutzerbasis großen Anklang finden.


Abbildung 6: Analyse von Bewegungsabläufen in Echtzeit mit Computer Vision
(https://mobidev.biz/wp-content/uploads/2020/07/detect-mistakes-knee-cave.gif)

Zusammenfassung

Computer Vision ist ein vielseitiges und vielversprechendes Feld von Machine Learning. Es verspricht die Lösung einer breiten Palette von Problemen in verschiedensten Branchen und Industrien. Das Verarbeiten von Bild- und Videomaterial in Echtzeit ermöglicht die Lösung von Problemstellungen weit komplexer als mit herkömmlichen Datenformaten. Das bringt den Stand von Machine Learning den «intelligenten» Systemen immer näher. Bereits heute bieten sich immer häufiger alltägliche Schnittstellen zu Computer Vision an – ein Trend, der sich in den kommenden Jahren nur zu beschleunigen scheint.

Die hier vorgestellten Beispiele sind nur die Spitze des Eisbergs. Tatsächlich gibt es in jeder der genannten Branchen große Bestrebungen mithilfe von Computer Vision Technologie bestehende Prozesse effizienter zu gestalten. Aktuell gibt es viele Bestrebungen Computer Vision in die dritte Dimension zu heben und anstelle von Fotos und Scans auch 3D-Modelle verarbeiten zu lassen. Die Nachfrage nach industrieller Bildverarbeitung in 3D wächst, sowohl in der Vermessung, der Medizin, wie auch der Robotik. Die Verarbeitung von 3D-Bildmaterial wird in den kommenden Jahren noch Beachtung erhalten, denn viele Problemstellungen lassen sich erst in 3D effizient lösen.

Oliver Guggenbühl Oliver Guggenbühl

NLP (engl. für Natural Language Processing) beschreibt allgemein das computergestützte Verarbeiten von menschlicher Sprache. Dies umfasst neben der geschriebenen auch die gesprochene Sprache. Die Ziele, die mit NLP verfolgt werden, lassen sich in zwei übergeordnete Kategorien einordnen: Verstehen von Sprache und Erzeugen von Sprache. Die technische Herausforderung ist bei beiden Zielen, unstrukturierte Informationen in Form von Texten in ein Format zu transferieren, das maschinell verarbeitet werden kann. Das bedeutet konkret, dass Texte in einem Zahlenformat repräsentiert werden müssen, welches der Computer verstehen kann.  

Noch vor wenigen Jahren war dies nur für einige wenige Technologiekonzerne möglich. Dabei hatten diese Firmen drei entscheidende Vorteile:

  • Zugang zu riesigen Mengen an unstrukturierten Textdaten
  • Fachleute, die in der Lage sind, cutting-edge Technologien zu entwickeln
  • Rechenkapazitäten, um die Menge an unstrukturierten Daten verarbeiten zu können

In diesem Artikel zeigen wir verschiedene Anwendungsgebiete von NLP und erklären, wie sich innerhalb nur weniger Jahre die Markteintrittsbarrieren so weit gesenkt haben, dass heute jedes Unternehmen NLP für eigene Lösungen nutzen kann.

In welchen Bereichen kann NLP eingesetzt werden?

Computergestützte Sprachverarbeitung ist ein sehr abstrakter Begriff. Verständlicher wird der Begriff, wenn man ihn in die Anwendungsgebiete herunterbricht. Dabei wird für jeden Teilbereich ein anderes, spezialisiertes Modell für die Sprachverarbeitung angewandt. Zu beachten ist dabei, dass Aufgaben, die einem Menschen eher leichtfallen, wie z.B. das Erkennen von Emotionen, auch für eine Maschine im NLP Bereich tendenziell eher einfach sind.. Andersherum sind auch kompliziertere Aufgaben, wie das Übersetzen von Texten, für den Computer eine tendenziell schwieriger zu lösende Aufgabe. Die sechs wichtigsten Anwendungen von NLP und die damit lösbaren Businessprobleme werden nachfolgend beleuchtet.

Sequenzklassifizierung

Das klassische Beispiel für NLP ist die Sequenzklassifizierung. Ziel ist es, Textsequenzen einer von mehreren vorher definierten Klassen zuzuordnen. Ein Beispiel für Klassen sind Emotionen (freudig, wütend, erheitert, usw.). Dem Computer wird ein Text vorgelegt und er muss selbstständig entscheiden, welche Emotion der Autor mit seinem Text ausdrücken wollte. Weitere Beispiele sind das Zuordnen eines Texts zu einem bekannten Autor oder das Klassifizieren von Dokumentarten.

Bei der Sequenzklassifizierung ist zu beachten, dass eine Sequenz aus einem Text beliebiger Länge bestehen kann. Eine Sequenz kann aus einem einzigen Wort (Sequenz von Buchstaben), einem Satz, einem Paragraphen, oder aber aus einem kompletten Dokument bestehen. Ein Beispiel für eine kürzere Sequenz wäre eine Urlaubsbewertung.

Anwendungsbeispiel 1:

Ein Reiseportal möchte spezifisch Kunden mit einer negativen Urlaubserfahrung in einer Marketingkampagne ansprechen. Dazu werden vorhandene Kundenbewertungen in drei Klassen unterteilen – Positiv, Neutral und Negativ. Jede Bewertung wird automatisch einer dieser Klassen zugeordnet.

Wobei längere Dokumente beispielsweise Postsendungen beliebiger Art sein könnten.

Anwendungsbeispiel 2:

Die Logistik-Abteilung einer internationalen Firma prozessiert verschiedene Dokumentarten in unterschiedlichen Teams. Dazu werden aktuell Postsendungen manuell selektiert und sortiert. Zukünftig werden diese automatisch einer Kategorie zuordnen. Als Kategorien könnten Eingehende Rechnungen, Lieferscheine sowie andere Anfragen definiert werden

Frage-Antwort Modelle

Bei Frage-Antwort Problemen wird dem Computer eine möglichst große Anzahl an Textkorpora zur Verfügung gestellt. Ziel ist es, auf Fragen, die von einem Person verfasst wurden, eine inhaltlich korrekte Antwort zu geben, die auf Informationen der Textkorpora basiert. Die Schwierigkeit dieser Aufgabe variiert, je nachdem wie konkret die benötigten Informationen im Text sind. Die einfachste Lösung ist  die komplette Extraktion vorhandener Textstellen. Darauf aufbauend kann die extrahierte Information in eine grammatikalisch korrekte Antwort verpackt werden. Am komplexesten zu implementieren sind logische Schlussfolgerungen basierend auf den vorhandenen Informationen.

Ein gegebener Text könnte beispielsweise die Struktur eines Firmengeländes beschreiben. Es werden dabei Gebäude A, B und C erwähnt. Eine mögliche Frage könnte lauten „Wie viele Gebäude sind auf dem Firmengelände vorhanden?“ Eine logische Schlussfolgerung des Computers wäre die Erkenntnis, dass das Gelände aus insgesamt 3 Gebäuden besteht, ohne, dass die Zahl an sich erwähnt wurde.

Anwendungsbeispiel 3:

Eine mittelständische Firma beobachtet seit längerer Zeit einen kontinuierlichen Anstieg an Kundenanfragen. Bei vielen dieser Anfragen handelt es sich um Auskunftsanfragen zu Informationen. Die Firma beschließt, einen Chatbot zu entwickeln. Basierend auf internen Supportdokumenten können Kunden nun selbstständig, automatisch Fragen an den Chatbot stellen und beantworten lassen.

Generierung von Texten

Basierend auf einem gegebenen Text soll möglichst genau das nächste passende Wort vorhergesagt werden. Der so entstandene Text kann wiederum zur Vorhersage von einem weiteren Wort benutzt werden. Dieser Vorgang kann beliebig oft wiederholt werden, um beliebig lange Texte zu erzeugen. Dabei ist es möglich, Texte mit beliebigen Sprachfeinheiten zu generieren. So kann ein bestimmter Akzent oder Dialekt modelliert werden, aber auch eine einfache oder komplexere Sprache verwendet werden, je nach Zielgruppe. Die größte Herausforderung ist, dass Text sowohl inhaltlich als auch sprachlich fehlerfrei sein sollte.

Anwendungsbeispiel 4:

Ein Hersteller eines Dokumentenverwaltungssystems möchte das Auffinden von Dokumenten einfacher gestalten. In der eingebauten Suchmaske wird der Suchbegriff automatisch mit weiteren passenden Wörtern ergänzt.

Erkennen von Satzgliedern

Bei dem Erkennen von Satzgliedern, auch Named Entity Recognition (NER) ist das Ziel, ein oder mehrere Wörter in einem Satz einer Klasse zuzuordnen. Als mögliche Satzglieder können grammatikalische Einheiten definiert werden. Dabei wird ein Satz gegliedert nach Subjekt, Prädikat, Objekt usw. Oft werden anstelle von grammatikalischen Einheiten benutzerdefinierte Entitäten gewählt. Oft sind die gesuchten Entitäten z.B. Orte, natürliche Personen, Firmen oder Zeiten. Wenn ein Mensch eine Entscheidung treffen muss, zu welcher Kategorie ein Satzglied gehört, greifen wir automatisch auf Regeln (wie z.B. Grammatikregeln) zurück. Bei NER soll der Computer lernen, auf ähnliche Entscheidungsregeln zurückzugreifen. Allerdings werden diese Regeln nicht explizit vorgegeben, stattdessen muss der Computer sich diese selbstständig erarbeiten.

Anwendungsbeispiel 5:

Ein Hedgefonds analysiert automatisch die eingereichten vierteljährlichen Berichte welche bei der Börsenaufsicht eingereicht werden. Ziel ist es, automatisch Zusammenfassungen der Geschäftsaktivität der Firma zu erstellen. So besteht die Liste der zu extrahierenden Identitäten aus Geschäftsart, Geschäftsbereich, Geschäftsführer usw.

Zusammenfassungen

Die Aufgabe, eine Zusammenfassung eines Textes zu erstellen, kann man sich exakt wie die Aufgabenstellung früher im Deutschunterricht vorstellen. Das Ziel ist es, eine möglichst echt wirkende, menschliche Zusammenfassung mit allen relevanten Inhalten zu erstellen. Dabei müssen selbstverständlich geltende Rechtschreib- und Grammatikregeln eingehalten werden. Die Herausforderung dabei ist es, dem Computer beizubringen wichtige und relevante Inhalte von unwichtigen Inhalten zu trennen.

Anwendungsbeispiel 6:

Eine Onlinenachrichtenagentur hat durch Analyse des Nutzungsverhalten der Website herausgefunden das immer weniger Leute die Artikel komplett bis zum Ende durchlesen. Um Lesern das extrahieren von relevanten Informationen zu erleichtern, soll automatisch eine Zusammenfassung für vorhandene und neuen Artikeln erstellt werden. Die Zusammenfassung soll in Länge und Sprachkomplexität abhängig vom Nutzerprofil erstellt werden.

Übersetzungen

Beim Anwendungsfall einer Textübersetzung soll der Text von einer Sprache in eine andere transferieren werden, unter Einhaltung der geltenden Rechtschreib- und Grammatikregeln und ohne den Inhalt zu verändern. Dabei hat der Computer ähnliche Probleme mit dem Übersetzen von Texten wie ein Mensch. Es muss stets die Balance zwischen inhaltlicher und grammatikalischer Korrektheit gehalten werden, ohne sich dabei vom Originaltext zu entfernen.

Anwendungsbeispiel 7:

Ein national agierender Zulieferbetrieb möchte seinen Absatzmarkt international erweitern. Dazu müssen alle vorhandenen technischen Spezifikationen in die Sprache der Zielmärkte übersetzt werden. Eine besondere Herausforderung besteht in der Übersetzung von technischen, branchenspezifischen Vokabular.

Wie haben sich die NLP-Modelle entwickelt?

Die Geschichte von NLP-Modellen lässt sich in drei Epochen unterteilen: Naive Modelle, statische Vektormodelle und dynamische Vektormodelle.

In den Anfängen von NLP Modellen wurde versucht, den Sinn von Texten durch das Zählen von Wörtern oder Wortpaaren zu ermitteln. Dazu war ein sehr intensives Vorbearbeiten der Texte notwendig. Das eigentliche Rechnen der Modelle, basierend auf den Zählständen, ist (mit heutigen Computern) äußerst schnell zu bewerkstelligen. Allerdings geht durch das Zählen der Wörter jeglicher Kontext verloren.

Der nächste Entwicklungsschritt waren statische Vektormodelle. Der Gedanke hinter diesen Modellen ist, dass jedes Wort durch einen Vektor, also eine Zahlenreihe, repräsentiert wird. Diese Zahlenreihen werden meist durch Zuhilfenahme von Deep Learning Modellen berechnet. Sie dienen anschließend als Eingabe für ein weiteres Modell, z.B. wiederum ein Deep Learning Modell, dass die Zahlenreihe nutzt, um damit die eigentliche Aufgabe, z.B. die Klassifikation der Texte, zu lösen. Durch Zuhilfenahme der Vektoren war es möglich, den Kontext von Wörtern besser zu erfassen. D.h. bei dem Berechnen eines Vektors für ein Wort werden andere, dieses Wort umgebende Wörter, mitbetrachtet. Allerdings sind die Vektoren für ein gleich geschriebenes Wort noch identisch, unabhängig von der eigentlichen Bedeutung. Bei dem unten gezeigten Beispiel wäre der Vektor für ‚Bank‘ jeweils der gleiche.

Ich sitze auf der Bank. (Bank = Sitzgelegenheit)

Ich bringe mein Geld zur Bank. (Bank = Geldhaus)

Das berechnen der Vektoren sowie des Modells ist sehr zeit- und rechenintensiv. Allerdings gestaltet sich die Vorhersage, durch den fehlenden Kontext der Vektoren, noch sehr effizient.

Die aktuellste Generation von NLP Modellen ist ähnlich der zweiten Generation, allerdings werden nun Vektoren mit Bezug auf den Kontext des Wortes berechnet. Somit würde in dem obenstehenden Beispiel für die Sitzbank ein anderer Vektor berechnet werden als für das Geldhaus. Das macht sowohl die Berechnung des Modells als auch die Vorhersage sehr rechenintensiv.

Wieso ist NLP so relevant geworden?

Den Beginn der „New-Area of NLP“ hat Google Ende 2018 mit dem sogenannten BERT Modell eingeläutet (hier geht es zum offiziellen GitHub repository). Seitdem erscheinen monatlich Anpassungen und Weiterentwicklungen des Modells von Universitäten, aber auch anderen Firmen wie Facebook und natürlich von Google selbst. Die Mehrheit dieser Modelle steht der breiten Masse kostenfrei zur Verfügung – fast immer ist die Verwendung auch für den kommerziellen Zweck freigegeben.

Die Performance dieser neusten Generation von NLP Modellen ist in vielen Bereichen auf Augenhöhe mit, oder bereits über, den Ergebnissen, die von Menschen erzielt werden können.

Die Forschung hat Datensätze für verschiedene Aufgaben und Teilbereiche der Sprachverarbeitung entwickelt. Diese Aufgaben wurden zunächst von Menschen gelöst, um einen Referenzwert zu schaffen, der von Computern geschlagen werden soll. Mittlerweile sind NLP Modelle in der Lage, in fast allen Bereichen nahezu menschliche Ergebnisse zu liefern.

Zu beachten ist, dass die Datensätze sehr generalistisch sind. Jeder dieser Benchmark-Datensätze versucht in seinem Teilbereich eine möglichst große Abdeckung zu erlangen, um eine möglichste gute, generelle Aussage über die Performance zu treffen. Businessprobleme hingegen sind meist deutlich konkreter. So kann es sein, dass ein Modell sehr gut in der Lage ist, die generelle Stimmung von Texten aller Art zu erfassen und somit eine gute, hohe Bewertung in diesem Bereich erlangt.

Ein Businessproblem könnte sein, dass die Stimmung von Kundenbeiträgen in sozialen Netzwerken oder von eingehenden Emails von Kundenbeschwerden zu bewerten. Von einem menschlichen Standpunkt aus gesehen, sind beide Aufgaben sehr ähnlich. Für eine Maschine kann es einen großen Unterscheid machen, ob es sich um kurze, informellen Texte, wie Beiträge aus sozialen Medien, oder um längere, formelle Texte, wie E-Mails, handelt. Eine Evaluation der Modelle auf das Business-Problem ist unerlässlich.

Wie ist NLP so gut anwendbar geworden?

Bis vor wenigen Jahren gab es in der Entwicklung von künstlicher Intelligenz,  und speziell für den Teilbereich NLP, drei grundlegende Probleme, die die Entwicklung und Adaption dieser Modelle erschwert hat. Die Probleme hingen mit der Ressourcenallokation in den drei Bereichen Daten, Rechenleistung und Humankapital zusammen. Alle drei Punkte wurden durch das Vortrainieren von Modellen deutlich entschärft.

Die großen, relevanten Firmen in der NLP-Modellentwicklung investieren in diese Ressourcen und stellen im Anschluss diese vortrainierten Modelle meist kostenfrei zur Verfügung. Die Modelle sind bereits sehr gut im generellen Verstehen von Texten, aber lassen meist noch Raum für Verbesserungen bei spezifischen Problemen. Der Löwenanteil an Ressourcen wird jedoch für den ersten Teil, dem generalistischen Repräsentieren von Text, benötigt. Diese vortrainierten Modelle lassen sich nun mit Verhältnis wenig Aufwand auf bestimmte Businessprobleme feinabstimmen. Durch das Feinabstimmten können exzellente Ergebnisse mit minimalstem Aufwand und geringen Kosten erzielt werden.

Einstiegsbarriere: Datenverfügbarkeit

Mit zunehmender Komplexität der Modelle wächst der Bedarf an Daten, welche für das Training benötigt werden, exponentiell. Die Performance dieser Modelle kommt durch das Betrachten des Kontextes eines Wortes zustande. Folglich ist es notwendig, dass ein Modell möglichst viele Wörter in möglichst vielen Kombinationen sieht. Durch das Internet gibt es Zugriff auf sehr große Textsammlungen. So wurde das vorhin erwähnte BERT Modell auf diversen Büchern mit zusammen etwa 800 Millionen Wörtern sowie der kompletten englischsprachigen Plattform Wikipedia mit etwa 2,5 Milliarden Wörtern trainiert.

Einstiegsbarriere: Rechenleistung

Aus dem immer weiter ansteigenden Bedarf an Daten sowie der ansteigenden Modellkomplexität ergibt sich ein immer größerer Bedarf an Rechenleistung. Dabei lassen sich einige Punkte beobachten. Die Leistung von Computern steigt jedes Jahr massiv an, man spricht von einer Verdoppelung der Rechenleistung etwa alle zwei Jahre. Gleichzeitig wird Rechenleistung immer günstiger. Seit dem Siegeszug von Cloudanbietern wurde der Zugang zu Rechenleistung demokratisiert. Extrem performante und spezialisierte Computercluster sind nun nicht mehr nur für große Firmen, sondern für jedermann bei einer minutengenauen Abrechnung verfügbar.

Einstiegsbarriere: Talentakquisition

In den Anfängen von KI war es notwendig, entweder selbst ein kompetitives Entwicklungsteam innerhalb der eigenen Organisation aufzubauen oder die komplette Entwicklung von spezialisierten Firmen einzukaufen. Dadurch war es erforderlich, finanziell sehr stark in Vorleistung zu gehen, um nach einer oft mehrjährigen Entwicklungszeit ein fertiges KI-Produkt in Betrieb nehmen zu können. Oft sind solche Projekte fehlgeschlagen oder haben einen zu geringen Mehrwert gestiftet. Finanzielle Investitionen mit solch einem Risikoprofil waren meist nur für große multinationale Unternehmen möglich. Die meisten der neu entwickelten NLP-Modelle sind heutzutage frei zugänglich, auch für kommerzielle Zwecke. Somit ist es möglich, innerhalb von Wochen, anstatt Monaten oder Jahren, einen Machbarkeitsnachweis zu bekommen. Die Einführungszeit eines kompletten Produktes hat sich von Jahren auf Monate reduziert. Iterationen in der Produktentwicklung sind nun sehr schnell möglich, mit einem geringen initialen Investment.

Welche Herausforderung bestehen weiterhin?

Viele der ursprünglich vorhandenen Probleme wurden entschärft oder komplett gelöst. Diese Entwicklungen haben vor allem den Zeitaufwand bis zum Abschluss einer Machbarkeitsstudie extrem verkürzt. 

Modell

Aktuell sind vortrainierte Modelle von einer Vielzahl an Firmen und Anbietern vorhanden. Diese werden laufend weiterentwickelt und oft wird nach einigen Monaten eine neuere, verbesserte Version veröffentlicht. Außerdem werden von ein- und demselben Modell zum gleichen Zeitpunkt mehrere Versionen veröffentlicht. Diese unterscheiden sich oftmals in der Komplexität oder der Sprache.

Es ist extrem wichtig, in der Anfangsphase eines NLP-Projekts Modelle zu sondieren und zu evaluieren. Grundsätzlich lässt sich die Performance in zwei verschiedene Dimensionen aufteilen: Die Qualität der Ergebnisse und die Ausführungsgeschwindigkeit.

Die Qualität von Modellergebnisse zu beurteilen, ist je nach Aufgabe häufig anspruchsvoll. Bei der Klassifizierung von Emotionen lässt sich meistens eindeutig bestimmen, ob das Modell richtig oder falsch lag. Das Beurteilen von Zusammenfassungen ist deutlich schwieriger. Es ist sehr wichtig in der Anfangsphase eines Projektes ein Gütemaß zu bestimmen, das technisch umsetzbar ist, aber auch das Businessproblem widerspiegelt.

Die zweite Dimension der Modellperformance ist die Ausführungsgeschwindigkeit. Diese umfasst sowohl die benötigte Zeit für das Training als auch für die Vorhersage. Dabei ist es sehr wichtig, frühzeitig den Anspruch an das Modell mit allen Projektpartnern abzustimmen. So hat ein Modell, welches live und innerhalb von Millisekunden Anfragen beantworten muss, andere Eigenschaften als ein Modell, welches einmal pro Tag über Nacht Ergebnisse berechnet.

Daten

Das Thema Daten ist generell bei KI und vor allem im Bereich NLP ein zweischneidiges Schwert. Einerseits sind Daten generell vorhanden und es existieren Computersysteme, die in der Lage sind, diese zu verarbeiten. Durch das Vortrainieren von Modellen wird uns ein Großteil der Arbeit mit Daten abgenommen. Andererseits sind vortrainierte Modelle immer darauf ausgelegt, möglichst gut in einer Vielzahl von Aufgaben zu funktionieren. Oft liefern die vortrainieren Modelle ohne eine Feinabstimmung bereits gute, aber keine herausragenden Ergebnisse.

Die Feinabstimmung erfolgt meist in zwei Dimensionen. Das Modell muss zunächst auf Spracheigenheiten und Feinheiten angepasst werden – das kann spezielles Vokabular sein, aber auch Slang und Dialekt. So gibt es einen großen Unterschied zwischen Beiträgen aus den Sozialen Medien und Anleitungen für produktionstechnische Verfahren.

Die zweite Dimension bezieht sich auf die eigentliche Aufgabenstellung. Um eine herausragende Leistung zu erlangen, müssen Modelle immer auf das Businessproblem abgestimmt werden. Ein Modell, das übersetzen kann, unterscheidet sich erheblich von einem Modell, das Emotionen klassifizieren kann. Für diese Feinabstimmung werden Texte/Daten benötigt, welche auf die Zielsprache und das Zielproblem abgestimmt sind. Die Texte müssen aufbereitet und dem Modell zugeführt werden. Je nach Komplexität und Qualität der Daten kann dies noch immer ein aufwendiger Prozess sein.

Rechenleistung

Der Fakt, dass Computer immer besser werden und Rechenleistung immer günstiger wird, ist einer der Hauptgründe für die Adaption von KI. Wie bereits mehrfach erwähnt, ist es durch vortrainierte Modelle nicht mehr notwendig, den Löwenanteil der Rechenleistung selbst zu erbringen. Computerleistung wird lediglich für die Datenverarbeitung und die Feinabstimmung der Modelle benötigt. Dies ist ein Bruchteil von der Rechenleistung, die für das komplette Training von Anfang bis Ende benötigt wird. Dennoch ist es meist mehr als ein Standard-Computer in einer angemessenen Zeit bewerkstelligen könnte. Daher wird für die Feinabstimmung meist auf Cloudcomputing zurückgegriffen. Cloudressourcen werden in der Regel minutengenau abgerechnet und sind daher sehr kostengünstig. Allerdings unterscheidet sich der Ablauf eines Trainings mittels Cloudcomputing deutlich von einem Training in einem Standard-Rechenzentrum, weswegen in diesem Bereich Wissen in der eigenen Organisation entweder aufgebaut oder von externen Dienstleistern eingekauft werden muss.

Was können wir in der Zukunft von NLP erwarten?

Vom gesamten Bereich der künstlichen Intelligenz wird an NLP aktuell am aktivsten geforscht. Es sind in den nächsten Monaten und Jahren noch einige interessante Entwicklungen zu erwarten und derzeit zeichnen sich zwei Entwicklungen mit sehr interessanten praktischen Implikationen ab.

Wir erwarten kurz- bis mittelfristig den praktischen Einsatz von sogenannten Zero-Shot Modellen. Diese Modelle sind für ein gewisses Aufgabengebiet wie Sequenzklassifikation trainiert. Die Neuheit ist, dass diese Modelle sehr gute Ergebnisse liefern, ohne jeweils domänenspezifische Daten gesehen zu haben. Somit entwickeln diese Modelle eine Art „generelle“ Intelligenz. Damit wird die Feinabstimmung von Modellen deutlich einfacher oder entfällt komplett.

Der nächste zu erwartende Schritt sind sogenannte General Purpose Modelle. Diese Art von Modellen können jedes Aufgabengebiet auf ungesehenen Daten lösen, wodurch die komplette Feinabstimmung entfallen würde. Erste Versuche mit diesen Modellen scheinen sehr gute Ergebnisse zu liefern, allerdings sind die Modelle extrem groß und stellen sehr hohe Anforderungen an die Rechenleistung. Damit ist die Inbetriebnahme dieser Modelle aktuell äußerst schwer und teuer. Noch gibt es nahezu keine praktischen Einsatzgebiete. Wir erwarten in den nächsten Jahren deutliche Sprünge hinsichtlich Praktikabilität und Performance.

Zusammenfassung

Die jüngsten Entwicklungen in dem Bereich der Sprachprozessierung sind beeindruckend und schnell zugleich. Den Startschuss der neusten Entwicklungen gab Google mit der Veröffentlichung des BERT-Modells vor knapp zwei Jahren und seitdem werden in einem Wochenrhythmus neue Modelle von Firmen und Universitäten rund um die Welt veröffentlicht. Diese Modelle verbessern oft die Ergebnisse von vorhandenen Problemen oder ermöglichen es, vorhandene Ressourcen effizienter einzusetzen. Probleme welche vor zwei Jahren noch als unlösbar galten sind nun oft sehr gut lösbar und auch im Hinblick auf einzusetzende Ressourcen und Entwicklungszeit erschwinglich. Die notwendige Zeit, eine Machbarkeitsstudie zu erstellen, wurde extrem verkürzt.

 

Dominique Lade Dominique Lade

NLP (engl. für Natural Language Processing) beschreibt allgemein das computergestützte Verarbeiten von menschlicher Sprache. Dies umfasst neben der geschriebenen auch die gesprochene Sprache. Die Ziele, die mit NLP verfolgt werden, lassen sich in zwei übergeordnete Kategorien einordnen: Verstehen von Sprache und Erzeugen von Sprache. Die technische Herausforderung ist bei beiden Zielen, unstrukturierte Informationen in Form von Texten in ein Format zu transferieren, das maschinell verarbeitet werden kann. Das bedeutet konkret, dass Texte in einem Zahlenformat repräsentiert werden müssen, welches der Computer verstehen kann.  

Noch vor wenigen Jahren war dies nur für einige wenige Technologiekonzerne möglich. Dabei hatten diese Firmen drei entscheidende Vorteile:

In diesem Artikel zeigen wir verschiedene Anwendungsgebiete von NLP und erklären, wie sich innerhalb nur weniger Jahre die Markteintrittsbarrieren so weit gesenkt haben, dass heute jedes Unternehmen NLP für eigene Lösungen nutzen kann.

In welchen Bereichen kann NLP eingesetzt werden?

Computergestützte Sprachverarbeitung ist ein sehr abstrakter Begriff. Verständlicher wird der Begriff, wenn man ihn in die Anwendungsgebiete herunterbricht. Dabei wird für jeden Teilbereich ein anderes, spezialisiertes Modell für die Sprachverarbeitung angewandt. Zu beachten ist dabei, dass Aufgaben, die einem Menschen eher leichtfallen, wie z.B. das Erkennen von Emotionen, auch für eine Maschine im NLP Bereich tendenziell eher einfach sind.. Andersherum sind auch kompliziertere Aufgaben, wie das Übersetzen von Texten, für den Computer eine tendenziell schwieriger zu lösende Aufgabe. Die sechs wichtigsten Anwendungen von NLP und die damit lösbaren Businessprobleme werden nachfolgend beleuchtet.

Sequenzklassifizierung

Das klassische Beispiel für NLP ist die Sequenzklassifizierung. Ziel ist es, Textsequenzen einer von mehreren vorher definierten Klassen zuzuordnen. Ein Beispiel für Klassen sind Emotionen (freudig, wütend, erheitert, usw.). Dem Computer wird ein Text vorgelegt und er muss selbstständig entscheiden, welche Emotion der Autor mit seinem Text ausdrücken wollte. Weitere Beispiele sind das Zuordnen eines Texts zu einem bekannten Autor oder das Klassifizieren von Dokumentarten.

Bei der Sequenzklassifizierung ist zu beachten, dass eine Sequenz aus einem Text beliebiger Länge bestehen kann. Eine Sequenz kann aus einem einzigen Wort (Sequenz von Buchstaben), einem Satz, einem Paragraphen, oder aber aus einem kompletten Dokument bestehen. Ein Beispiel für eine kürzere Sequenz wäre eine Urlaubsbewertung.

Anwendungsbeispiel 1:

Ein Reiseportal möchte spezifisch Kunden mit einer negativen Urlaubserfahrung in einer Marketingkampagne ansprechen. Dazu werden vorhandene Kundenbewertungen in drei Klassen unterteilen – Positiv, Neutral und Negativ. Jede Bewertung wird automatisch einer dieser Klassen zugeordnet.

Wobei längere Dokumente beispielsweise Postsendungen beliebiger Art sein könnten.

Anwendungsbeispiel 2:

Die Logistik-Abteilung einer internationalen Firma prozessiert verschiedene Dokumentarten in unterschiedlichen Teams. Dazu werden aktuell Postsendungen manuell selektiert und sortiert. Zukünftig werden diese automatisch einer Kategorie zuordnen. Als Kategorien könnten Eingehende Rechnungen, Lieferscheine sowie andere Anfragen definiert werden

Frage-Antwort Modelle

Bei Frage-Antwort Problemen wird dem Computer eine möglichst große Anzahl an Textkorpora zur Verfügung gestellt. Ziel ist es, auf Fragen, die von einem Person verfasst wurden, eine inhaltlich korrekte Antwort zu geben, die auf Informationen der Textkorpora basiert. Die Schwierigkeit dieser Aufgabe variiert, je nachdem wie konkret die benötigten Informationen im Text sind. Die einfachste Lösung ist  die komplette Extraktion vorhandener Textstellen. Darauf aufbauend kann die extrahierte Information in eine grammatikalisch korrekte Antwort verpackt werden. Am komplexesten zu implementieren sind logische Schlussfolgerungen basierend auf den vorhandenen Informationen.

Ein gegebener Text könnte beispielsweise die Struktur eines Firmengeländes beschreiben. Es werden dabei Gebäude A, B und C erwähnt. Eine mögliche Frage könnte lauten „Wie viele Gebäude sind auf dem Firmengelände vorhanden?“ Eine logische Schlussfolgerung des Computers wäre die Erkenntnis, dass das Gelände aus insgesamt 3 Gebäuden besteht, ohne, dass die Zahl an sich erwähnt wurde.

Anwendungsbeispiel 3:

Eine mittelständische Firma beobachtet seit längerer Zeit einen kontinuierlichen Anstieg an Kundenanfragen. Bei vielen dieser Anfragen handelt es sich um Auskunftsanfragen zu Informationen. Die Firma beschließt, einen Chatbot zu entwickeln. Basierend auf internen Supportdokumenten können Kunden nun selbstständig, automatisch Fragen an den Chatbot stellen und beantworten lassen.

Generierung von Texten

Basierend auf einem gegebenen Text soll möglichst genau das nächste passende Wort vorhergesagt werden. Der so entstandene Text kann wiederum zur Vorhersage von einem weiteren Wort benutzt werden. Dieser Vorgang kann beliebig oft wiederholt werden, um beliebig lange Texte zu erzeugen. Dabei ist es möglich, Texte mit beliebigen Sprachfeinheiten zu generieren. So kann ein bestimmter Akzent oder Dialekt modelliert werden, aber auch eine einfache oder komplexere Sprache verwendet werden, je nach Zielgruppe. Die größte Herausforderung ist, dass Text sowohl inhaltlich als auch sprachlich fehlerfrei sein sollte.

Anwendungsbeispiel 4:

Ein Hersteller eines Dokumentenverwaltungssystems möchte das Auffinden von Dokumenten einfacher gestalten. In der eingebauten Suchmaske wird der Suchbegriff automatisch mit weiteren passenden Wörtern ergänzt.

Erkennen von Satzgliedern

Bei dem Erkennen von Satzgliedern, auch Named Entity Recognition (NER) ist das Ziel, ein oder mehrere Wörter in einem Satz einer Klasse zuzuordnen. Als mögliche Satzglieder können grammatikalische Einheiten definiert werden. Dabei wird ein Satz gegliedert nach Subjekt, Prädikat, Objekt usw. Oft werden anstelle von grammatikalischen Einheiten benutzerdefinierte Entitäten gewählt. Oft sind die gesuchten Entitäten z.B. Orte, natürliche Personen, Firmen oder Zeiten. Wenn ein Mensch eine Entscheidung treffen muss, zu welcher Kategorie ein Satzglied gehört, greifen wir automatisch auf Regeln (wie z.B. Grammatikregeln) zurück. Bei NER soll der Computer lernen, auf ähnliche Entscheidungsregeln zurückzugreifen. Allerdings werden diese Regeln nicht explizit vorgegeben, stattdessen muss der Computer sich diese selbstständig erarbeiten.

Anwendungsbeispiel 5:

Ein Hedgefonds analysiert automatisch die eingereichten vierteljährlichen Berichte welche bei der Börsenaufsicht eingereicht werden. Ziel ist es, automatisch Zusammenfassungen der Geschäftsaktivität der Firma zu erstellen. So besteht die Liste der zu extrahierenden Identitäten aus Geschäftsart, Geschäftsbereich, Geschäftsführer usw.

Zusammenfassungen

Die Aufgabe, eine Zusammenfassung eines Textes zu erstellen, kann man sich exakt wie die Aufgabenstellung früher im Deutschunterricht vorstellen. Das Ziel ist es, eine möglichst echt wirkende, menschliche Zusammenfassung mit allen relevanten Inhalten zu erstellen. Dabei müssen selbstverständlich geltende Rechtschreib- und Grammatikregeln eingehalten werden. Die Herausforderung dabei ist es, dem Computer beizubringen wichtige und relevante Inhalte von unwichtigen Inhalten zu trennen.

Anwendungsbeispiel 6:

Eine Onlinenachrichtenagentur hat durch Analyse des Nutzungsverhalten der Website herausgefunden das immer weniger Leute die Artikel komplett bis zum Ende durchlesen. Um Lesern das extrahieren von relevanten Informationen zu erleichtern, soll automatisch eine Zusammenfassung für vorhandene und neuen Artikeln erstellt werden. Die Zusammenfassung soll in Länge und Sprachkomplexität abhängig vom Nutzerprofil erstellt werden.

Übersetzungen

Beim Anwendungsfall einer Textübersetzung soll der Text von einer Sprache in eine andere transferieren werden, unter Einhaltung der geltenden Rechtschreib- und Grammatikregeln und ohne den Inhalt zu verändern. Dabei hat der Computer ähnliche Probleme mit dem Übersetzen von Texten wie ein Mensch. Es muss stets die Balance zwischen inhaltlicher und grammatikalischer Korrektheit gehalten werden, ohne sich dabei vom Originaltext zu entfernen.

Anwendungsbeispiel 7:

Ein national agierender Zulieferbetrieb möchte seinen Absatzmarkt international erweitern. Dazu müssen alle vorhandenen technischen Spezifikationen in die Sprache der Zielmärkte übersetzt werden. Eine besondere Herausforderung besteht in der Übersetzung von technischen, branchenspezifischen Vokabular.

Wie haben sich die NLP-Modelle entwickelt?

Die Geschichte von NLP-Modellen lässt sich in drei Epochen unterteilen: Naive Modelle, statische Vektormodelle und dynamische Vektormodelle.

In den Anfängen von NLP Modellen wurde versucht, den Sinn von Texten durch das Zählen von Wörtern oder Wortpaaren zu ermitteln. Dazu war ein sehr intensives Vorbearbeiten der Texte notwendig. Das eigentliche Rechnen der Modelle, basierend auf den Zählständen, ist (mit heutigen Computern) äußerst schnell zu bewerkstelligen. Allerdings geht durch das Zählen der Wörter jeglicher Kontext verloren.

Der nächste Entwicklungsschritt waren statische Vektormodelle. Der Gedanke hinter diesen Modellen ist, dass jedes Wort durch einen Vektor, also eine Zahlenreihe, repräsentiert wird. Diese Zahlenreihen werden meist durch Zuhilfenahme von Deep Learning Modellen berechnet. Sie dienen anschließend als Eingabe für ein weiteres Modell, z.B. wiederum ein Deep Learning Modell, dass die Zahlenreihe nutzt, um damit die eigentliche Aufgabe, z.B. die Klassifikation der Texte, zu lösen. Durch Zuhilfenahme der Vektoren war es möglich, den Kontext von Wörtern besser zu erfassen. D.h. bei dem Berechnen eines Vektors für ein Wort werden andere, dieses Wort umgebende Wörter, mitbetrachtet. Allerdings sind die Vektoren für ein gleich geschriebenes Wort noch identisch, unabhängig von der eigentlichen Bedeutung. Bei dem unten gezeigten Beispiel wäre der Vektor für ‚Bank‘ jeweils der gleiche.

Ich sitze auf der Bank. (Bank = Sitzgelegenheit)

Ich bringe mein Geld zur Bank. (Bank = Geldhaus)

Das berechnen der Vektoren sowie des Modells ist sehr zeit- und rechenintensiv. Allerdings gestaltet sich die Vorhersage, durch den fehlenden Kontext der Vektoren, noch sehr effizient.

Die aktuellste Generation von NLP Modellen ist ähnlich der zweiten Generation, allerdings werden nun Vektoren mit Bezug auf den Kontext des Wortes berechnet. Somit würde in dem obenstehenden Beispiel für die Sitzbank ein anderer Vektor berechnet werden als für das Geldhaus. Das macht sowohl die Berechnung des Modells als auch die Vorhersage sehr rechenintensiv.

Wieso ist NLP so relevant geworden?

Den Beginn der „New-Area of NLP“ hat Google Ende 2018 mit dem sogenannten BERT Modell eingeläutet (hier geht es zum offiziellen GitHub repository). Seitdem erscheinen monatlich Anpassungen und Weiterentwicklungen des Modells von Universitäten, aber auch anderen Firmen wie Facebook und natürlich von Google selbst. Die Mehrheit dieser Modelle steht der breiten Masse kostenfrei zur Verfügung – fast immer ist die Verwendung auch für den kommerziellen Zweck freigegeben.

Die Performance dieser neusten Generation von NLP Modellen ist in vielen Bereichen auf Augenhöhe mit, oder bereits über, den Ergebnissen, die von Menschen erzielt werden können.

Die Forschung hat Datensätze für verschiedene Aufgaben und Teilbereiche der Sprachverarbeitung entwickelt. Diese Aufgaben wurden zunächst von Menschen gelöst, um einen Referenzwert zu schaffen, der von Computern geschlagen werden soll. Mittlerweile sind NLP Modelle in der Lage, in fast allen Bereichen nahezu menschliche Ergebnisse zu liefern.

Zu beachten ist, dass die Datensätze sehr generalistisch sind. Jeder dieser Benchmark-Datensätze versucht in seinem Teilbereich eine möglichst große Abdeckung zu erlangen, um eine möglichste gute, generelle Aussage über die Performance zu treffen. Businessprobleme hingegen sind meist deutlich konkreter. So kann es sein, dass ein Modell sehr gut in der Lage ist, die generelle Stimmung von Texten aller Art zu erfassen und somit eine gute, hohe Bewertung in diesem Bereich erlangt.

Ein Businessproblem könnte sein, dass die Stimmung von Kundenbeiträgen in sozialen Netzwerken oder von eingehenden Emails von Kundenbeschwerden zu bewerten. Von einem menschlichen Standpunkt aus gesehen, sind beide Aufgaben sehr ähnlich. Für eine Maschine kann es einen großen Unterscheid machen, ob es sich um kurze, informellen Texte, wie Beiträge aus sozialen Medien, oder um längere, formelle Texte, wie E-Mails, handelt. Eine Evaluation der Modelle auf das Business-Problem ist unerlässlich.

Wie ist NLP so gut anwendbar geworden?

Bis vor wenigen Jahren gab es in der Entwicklung von künstlicher Intelligenz,  und speziell für den Teilbereich NLP, drei grundlegende Probleme, die die Entwicklung und Adaption dieser Modelle erschwert hat. Die Probleme hingen mit der Ressourcenallokation in den drei Bereichen Daten, Rechenleistung und Humankapital zusammen. Alle drei Punkte wurden durch das Vortrainieren von Modellen deutlich entschärft.

Die großen, relevanten Firmen in der NLP-Modellentwicklung investieren in diese Ressourcen und stellen im Anschluss diese vortrainierten Modelle meist kostenfrei zur Verfügung. Die Modelle sind bereits sehr gut im generellen Verstehen von Texten, aber lassen meist noch Raum für Verbesserungen bei spezifischen Problemen. Der Löwenanteil an Ressourcen wird jedoch für den ersten Teil, dem generalistischen Repräsentieren von Text, benötigt. Diese vortrainierten Modelle lassen sich nun mit Verhältnis wenig Aufwand auf bestimmte Businessprobleme feinabstimmen. Durch das Feinabstimmten können exzellente Ergebnisse mit minimalstem Aufwand und geringen Kosten erzielt werden.

Einstiegsbarriere: Datenverfügbarkeit

Mit zunehmender Komplexität der Modelle wächst der Bedarf an Daten, welche für das Training benötigt werden, exponentiell. Die Performance dieser Modelle kommt durch das Betrachten des Kontextes eines Wortes zustande. Folglich ist es notwendig, dass ein Modell möglichst viele Wörter in möglichst vielen Kombinationen sieht. Durch das Internet gibt es Zugriff auf sehr große Textsammlungen. So wurde das vorhin erwähnte BERT Modell auf diversen Büchern mit zusammen etwa 800 Millionen Wörtern sowie der kompletten englischsprachigen Plattform Wikipedia mit etwa 2,5 Milliarden Wörtern trainiert.

Einstiegsbarriere: Rechenleistung

Aus dem immer weiter ansteigenden Bedarf an Daten sowie der ansteigenden Modellkomplexität ergibt sich ein immer größerer Bedarf an Rechenleistung. Dabei lassen sich einige Punkte beobachten. Die Leistung von Computern steigt jedes Jahr massiv an, man spricht von einer Verdoppelung der Rechenleistung etwa alle zwei Jahre. Gleichzeitig wird Rechenleistung immer günstiger. Seit dem Siegeszug von Cloudanbietern wurde der Zugang zu Rechenleistung demokratisiert. Extrem performante und spezialisierte Computercluster sind nun nicht mehr nur für große Firmen, sondern für jedermann bei einer minutengenauen Abrechnung verfügbar.

Einstiegsbarriere: Talentakquisition

In den Anfängen von KI war es notwendig, entweder selbst ein kompetitives Entwicklungsteam innerhalb der eigenen Organisation aufzubauen oder die komplette Entwicklung von spezialisierten Firmen einzukaufen. Dadurch war es erforderlich, finanziell sehr stark in Vorleistung zu gehen, um nach einer oft mehrjährigen Entwicklungszeit ein fertiges KI-Produkt in Betrieb nehmen zu können. Oft sind solche Projekte fehlgeschlagen oder haben einen zu geringen Mehrwert gestiftet. Finanzielle Investitionen mit solch einem Risikoprofil waren meist nur für große multinationale Unternehmen möglich. Die meisten der neu entwickelten NLP-Modelle sind heutzutage frei zugänglich, auch für kommerzielle Zwecke. Somit ist es möglich, innerhalb von Wochen, anstatt Monaten oder Jahren, einen Machbarkeitsnachweis zu bekommen. Die Einführungszeit eines kompletten Produktes hat sich von Jahren auf Monate reduziert. Iterationen in der Produktentwicklung sind nun sehr schnell möglich, mit einem geringen initialen Investment.

Welche Herausforderung bestehen weiterhin?

Viele der ursprünglich vorhandenen Probleme wurden entschärft oder komplett gelöst. Diese Entwicklungen haben vor allem den Zeitaufwand bis zum Abschluss einer Machbarkeitsstudie extrem verkürzt. 

Modell

Aktuell sind vortrainierte Modelle von einer Vielzahl an Firmen und Anbietern vorhanden. Diese werden laufend weiterentwickelt und oft wird nach einigen Monaten eine neuere, verbesserte Version veröffentlicht. Außerdem werden von ein- und demselben Modell zum gleichen Zeitpunkt mehrere Versionen veröffentlicht. Diese unterscheiden sich oftmals in der Komplexität oder der Sprache.

Es ist extrem wichtig, in der Anfangsphase eines NLP-Projekts Modelle zu sondieren und zu evaluieren. Grundsätzlich lässt sich die Performance in zwei verschiedene Dimensionen aufteilen: Die Qualität der Ergebnisse und die Ausführungsgeschwindigkeit.

Die Qualität von Modellergebnisse zu beurteilen, ist je nach Aufgabe häufig anspruchsvoll. Bei der Klassifizierung von Emotionen lässt sich meistens eindeutig bestimmen, ob das Modell richtig oder falsch lag. Das Beurteilen von Zusammenfassungen ist deutlich schwieriger. Es ist sehr wichtig in der Anfangsphase eines Projektes ein Gütemaß zu bestimmen, das technisch umsetzbar ist, aber auch das Businessproblem widerspiegelt.

Die zweite Dimension der Modellperformance ist die Ausführungsgeschwindigkeit. Diese umfasst sowohl die benötigte Zeit für das Training als auch für die Vorhersage. Dabei ist es sehr wichtig, frühzeitig den Anspruch an das Modell mit allen Projektpartnern abzustimmen. So hat ein Modell, welches live und innerhalb von Millisekunden Anfragen beantworten muss, andere Eigenschaften als ein Modell, welches einmal pro Tag über Nacht Ergebnisse berechnet.

Daten

Das Thema Daten ist generell bei KI und vor allem im Bereich NLP ein zweischneidiges Schwert. Einerseits sind Daten generell vorhanden und es existieren Computersysteme, die in der Lage sind, diese zu verarbeiten. Durch das Vortrainieren von Modellen wird uns ein Großteil der Arbeit mit Daten abgenommen. Andererseits sind vortrainierte Modelle immer darauf ausgelegt, möglichst gut in einer Vielzahl von Aufgaben zu funktionieren. Oft liefern die vortrainieren Modelle ohne eine Feinabstimmung bereits gute, aber keine herausragenden Ergebnisse.

Die Feinabstimmung erfolgt meist in zwei Dimensionen. Das Modell muss zunächst auf Spracheigenheiten und Feinheiten angepasst werden – das kann spezielles Vokabular sein, aber auch Slang und Dialekt. So gibt es einen großen Unterschied zwischen Beiträgen aus den Sozialen Medien und Anleitungen für produktionstechnische Verfahren.

Die zweite Dimension bezieht sich auf die eigentliche Aufgabenstellung. Um eine herausragende Leistung zu erlangen, müssen Modelle immer auf das Businessproblem abgestimmt werden. Ein Modell, das übersetzen kann, unterscheidet sich erheblich von einem Modell, das Emotionen klassifizieren kann. Für diese Feinabstimmung werden Texte/Daten benötigt, welche auf die Zielsprache und das Zielproblem abgestimmt sind. Die Texte müssen aufbereitet und dem Modell zugeführt werden. Je nach Komplexität und Qualität der Daten kann dies noch immer ein aufwendiger Prozess sein.

Rechenleistung

Der Fakt, dass Computer immer besser werden und Rechenleistung immer günstiger wird, ist einer der Hauptgründe für die Adaption von KI. Wie bereits mehrfach erwähnt, ist es durch vortrainierte Modelle nicht mehr notwendig, den Löwenanteil der Rechenleistung selbst zu erbringen. Computerleistung wird lediglich für die Datenverarbeitung und die Feinabstimmung der Modelle benötigt. Dies ist ein Bruchteil von der Rechenleistung, die für das komplette Training von Anfang bis Ende benötigt wird. Dennoch ist es meist mehr als ein Standard-Computer in einer angemessenen Zeit bewerkstelligen könnte. Daher wird für die Feinabstimmung meist auf Cloudcomputing zurückgegriffen. Cloudressourcen werden in der Regel minutengenau abgerechnet und sind daher sehr kostengünstig. Allerdings unterscheidet sich der Ablauf eines Trainings mittels Cloudcomputing deutlich von einem Training in einem Standard-Rechenzentrum, weswegen in diesem Bereich Wissen in der eigenen Organisation entweder aufgebaut oder von externen Dienstleistern eingekauft werden muss.

Was können wir in der Zukunft von NLP erwarten?

Vom gesamten Bereich der künstlichen Intelligenz wird an NLP aktuell am aktivsten geforscht. Es sind in den nächsten Monaten und Jahren noch einige interessante Entwicklungen zu erwarten und derzeit zeichnen sich zwei Entwicklungen mit sehr interessanten praktischen Implikationen ab.

Wir erwarten kurz- bis mittelfristig den praktischen Einsatz von sogenannten Zero-Shot Modellen. Diese Modelle sind für ein gewisses Aufgabengebiet wie Sequenzklassifikation trainiert. Die Neuheit ist, dass diese Modelle sehr gute Ergebnisse liefern, ohne jeweils domänenspezifische Daten gesehen zu haben. Somit entwickeln diese Modelle eine Art „generelle“ Intelligenz. Damit wird die Feinabstimmung von Modellen deutlich einfacher oder entfällt komplett.

Der nächste zu erwartende Schritt sind sogenannte General Purpose Modelle. Diese Art von Modellen können jedes Aufgabengebiet auf ungesehenen Daten lösen, wodurch die komplette Feinabstimmung entfallen würde. Erste Versuche mit diesen Modellen scheinen sehr gute Ergebnisse zu liefern, allerdings sind die Modelle extrem groß und stellen sehr hohe Anforderungen an die Rechenleistung. Damit ist die Inbetriebnahme dieser Modelle aktuell äußerst schwer und teuer. Noch gibt es nahezu keine praktischen Einsatzgebiete. Wir erwarten in den nächsten Jahren deutliche Sprünge hinsichtlich Praktikabilität und Performance.

Zusammenfassung

Die jüngsten Entwicklungen in dem Bereich der Sprachprozessierung sind beeindruckend und schnell zugleich. Den Startschuss der neusten Entwicklungen gab Google mit der Veröffentlichung des BERT-Modells vor knapp zwei Jahren und seitdem werden in einem Wochenrhythmus neue Modelle von Firmen und Universitäten rund um die Welt veröffentlicht. Diese Modelle verbessern oft die Ergebnisse von vorhandenen Problemen oder ermöglichen es, vorhandene Ressourcen effizienter einzusetzen. Probleme welche vor zwei Jahren noch als unlösbar galten sind nun oft sehr gut lösbar und auch im Hinblick auf einzusetzende Ressourcen und Entwicklungszeit erschwinglich. Die notwendige Zeit, eine Machbarkeitsstudie zu erstellen, wurde extrem verkürzt.

 

Dominique Lade Dominique Lade