German Bert Applications

German BERT Applications
Google BERT – deutschsprachige

Anwendungen entwickeln und bereitstellen
Priv.-Doz. Dr. Dimiter Nasev

nasev@next-rtc.com
www.next-rtc.com
Inhaltsverzeichnis
1. German BERT Model Selection....................................................................................................... 3

Abstract ................................................................................................................................................... 3
1.1. Modell ................................................................................................................................................ 4
1.2. Daten ................................................................................................................................................. 6
1.3. Feintunen ........................................................................................................................................... 6
1.4. Evaluieren .......................................................................................................................................... 8
1.5. Export................................................................................................................................................. 9
1.6. Bereitstellen ..................................................................................................................................... 10
2. German News Topic Prediction .................................................................................................... 13
Abstract ................................................................................................................................................. 13
2.1. Einführung........................................................................................................................................ 13
2.2. Daten ............................................................................................................................................... 14
2.3. Feintunen, Evaluieren und Bereitstellen........................................................................................... 15
3. German Customer Posts Sentiment Prediction .......................................................................... 17
Abstract ................................................................................................................................................. 17
3.1. Einführung........................................................................................................................................ 17
3.2. Daten ............................................................................................................................................... 18
3.3. Feintunen, Evaluieren und Bereitstellen........................................................................................... 19
4. German BERT Sentence Embeddings ......................................................................................... 21
Abstract ................................................................................................................................................. 21
4.1. Semantische Ähnlichkeit .................................................................................................................. 22
4.2. Texte vergleichen............................................................................................................................. 24
4.3. FAQ Geldwäsche ............................................................................................................................. 27
4.4. FAQ Coronavirus ............................................................................................................................. 30
4.5. Nachrichten thematisieren ............................................................................................................... 33
4.6. Kundenstimmung messen................................................................................................................ 36
4.7. Semantische Suche ......................................................................................................................... 39
4.8. Regressionsmodelle......................................................................................................................... 40
4.8.1. Multiple lineare Regression.................................................................................................... 40
4.8.2. Logistische Regression/Klassifikation .................................................................................. 41
4.8.3. Lasso und Ridge Regression.................................................................................................. 41
4.8.4. Regression mit Scikit-learn ................................................................................................... 42
5. Fine-tuning vs. Sentence Embeddings ........................................................................................ 43
6. Pre-training with BERT ......................................................................................................... 45

Abstract................................................................................................................................................... 45
6.1. Two kinds of Pre-training ................................................................................................................. 46
6.2. Domain-specific BERT Models................................................................................................... 48
6.3. Domain-specific German BERT Applications .......................................................................... 48
6.3.1. German ClinicalBERT .............................................................................................................. 48
6.3.2. German FinBERT...................................................................................................................... 48
7. Company knowledge on Demand....................................................................................... 50
8. Multilingual BERT Applications ........................................................................................... 50
9. contactApps Datenverwaltung in Textdateien.............................................................. 51
10. Digital Transformation ........................................................................................................... 53
References.......................................................................................................................................... 55
German BERT Applications -2-

1. German BERT Model Selection
Abstract
Ende 2018 haben Google-Entwickler eine neue Technik für die

Verarbeitung natürlicher Sprache (NLP) namens BERT (Bidirectional
Encoder Representations from Transformers) als Open-Source-Lösung
bereitgestellt (Devlin et al. 2018).
Für deutschsprachige Anwendungen braucht man ein deutschsprachiges

BERT-Modell. Ein solches Modell wird mit deutschen Texten antrainiert.
Google Multilingual BERT unterstützt auch die deutsche Sprache und kann
für deutschsprachige Aufgabenstellungen eingesetzt werden. Es gibt z. Z.
darüber hinaus andere Sprachmodelle, die angeblich etwas besser (bis zu
3%) abschneiden, als Google Multilingual BERT. Aus diesem Grund
untersuchen wir im Weiteren auch das deutschsprachige Deepset BERT-
Modell.
Für unsere vergleichenden Untersuchungen haben wir GermEval-Daten

aus 2018 und 2019 verwendet. Das GermEval-Projekt sucht u.a. nach
Möglichkeiten, beleidigende deutschsprachige Tweets automatisch zu
erkennen (Risch et al. 2019).
Bei unseren Untersuchungen schneidet Deepset BERT marginal besser (ca.

1,4%) als Google Multilingual BERT ab.
Die für Flask bzw. TensorFlow Serving exportierten Dateien sind bei
Deepset BERT um 270 MB sowie die vocab-Datei um 724 KB kleiner.
Die Performance beim Serving ist nahezu identisch, da das Laden der
Dateien ein einmaliger Vorgang ist (beim Starten der Server). Die
Antwortzeit auf einem Ubuntu 16.04 Server beträgt ca. 1s.

1.1. Modell
Es gibt verschiedene Verfahren, mit denen man Texte analysiert und nach
bestimmten Kriterien klassifiziert. Es wurde bereits gezeigt, dass BERT -
Bidirectional Encoder Representations from Transformers (Devlin et al.
2018) dabei die besten Ergebnisse erzielt.
BERT basiert auf einem Transformer-Modell. Ein Transformer besteht aus

einem Codierer zum Lesen der Texteingabe und einem Decodierer zum
Erstellen einer Vorhersage für die Aufgabe. Da es das Ziel von BERT ist,
ein Sprachrepräsentationsmodell zu generieren, wird nur der Encoderteil
benötigt. Die Eingabe in den Codierer für BERT ist eine Folge von Token,
die zuerst in Vektoren (Einbettungen = Embeddings) umgewandelt und
dann im neuronalen Netzwerk verarbeitet werden.
Beispiel: Text A = “my dog is cute”; Text B = “he likes playing”
Tokeneinbettungen: Ein [CLS] -Token wird am Anfang und ein [SEP] -

Token wird am Ende jedes Textes (Text = Sentence) eingefügt.

Segmenteinbettungen: Jedem Token wird eine Markierung hinzugefügt,
die Text A oder Text B anzeigt. Dadurch kann der Encoder zwischen den
beiden Texten unterscheiden.
Positionseinbettungen: Jedem Token wird eine Positionseinbettung

hinzugefügt, um seine Position im Text anzuzeigen.
Zwei Faktoren sind maßgeblich für die Überlegenheit der BERT-Modelle

verantwortlich:
1. Das BERT-Modell (Anwendung) entsteht in zwei Schritte. Zuerst

wird ein „leeres“ Modell mit einer sehr großen Menge an
ungelabelten Daten (Texte) antrainiert (pre-training) und
anschließend mit lösungsorientierten gelableten Daten fein
abgestimmt (fine-tuning). Während das Pre-training ein
einmaliger, sehr aufwendiger Vorgang ist, erfolgt das Feintunen
aufgabenorientiert in Minuten bis zu einigen wenigen Stunden.
Deshalb bietet Google verschiedene bereits antrainierte Modelle an.
Für deutschsprachige Anwendungen braucht man ein
deutschsprachiges BERT-Modell. Ein solches Modell wird mit
deutschen Texten antrainiert. Google Multilingual BERT unterstützt
auch die deutsche Sprache und kann für deutschsprachige
Aufgabenstellungen eingesetzt werden. Es gibt z.Z. darüber hinaus
auch andere Sprachmodelle, die angeblich etwas besser (bis zu 3%)
abschneiden, als Google Multilingual BERT. Aus diesem Grund
untersuchen wir im Weiteren vergleichend auch das Deepset BERT-
Modell (https://deepset.ai/german-bert).
2. Das BERT-Modell wird so trainiert, dass eine optimale Vorhersage

von „maskierten“ Wörtern (Token) im Text (bis zu 15% maskiert)
erreicht wird (MLM = Masked LM). Neben MLM ist auch NSP
(Next Sentence Prediction) Bestandteil der BERT-Verlustfunktion.
Während des Trainings lernt das Modell vorherzusagen, ob der
zweite Text (Text B) auch der nächste Text im Originaltext ist. Beim
Anlernen ist die bidirektionale Vorgehensweise besser im Vergleich
zu der einseitigen „von-links-nach-rechts“ bzw. „von-rechts-nach-
links“.
Im Weiteren setzen wir ausschließlich auf TensorFlow BERT und Serving:
https://github.com/google-research/bert
https://github.com/tensorflow/serving.

1.2. Daten
Für unsere vergleichenden Untersuchungen haben wir GermEval-Daten

aus 2018 und 2019 verwendet:
https://projects.fzai.h-da.de/iggsa/data-2019/.
Das Projekt sucht u.a. nach Möglichkeiten, beleidigende deutschsprachige

Tweets automatisch zu erkennen. Diese Fragestellung (textbasierte
Klassifikation) kann am besten mit BERT gelöst werden (Risch et al.
2019).
Das Trainingsdatenset (train.tsv) betrug gut 12.000 Tweets aus 2018 und
2019. Das Evaluierungsdatenset (dev.tsv) bestand aus gut 3.000 Tweets
aus 2019. Beide Datensets enthielten gelabelte (0 – nicht beleidigend und
1 - beleidigend) deutschsprachige Tweets:
# Label / Polarity
label_list = [0, 1]
labels = ["nicht beleidigend", "beleidigend"]

# Gelabelte Dataframes (df_train, df_eval)
# id label text_b sentence
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# text_b ‐ None
# sentence (text_a) ‐ Tweet
df_train.to_csv(‘train.tsv’, sep = '\t', index=True, header=False)
df_eval.to_csv(‘dev.tsv’, sep = '\t', index=True, header=False)
1.3. Feintunen
Das Feintunen (mit train.tsv) von Google Multilingual BERT sowie Deepset
BERT erfolgte mit Google Colab (GPU) auf Google Drive:
# Google Drive anbinden
from google.colab import drive
drive.mount("/content/gdrive", force_remount=True)

import os
os.chdir("gdrive/My Drive")

# Feintunen und Export mit Google Multilingual BERT
!python run_new_classifier.py \
‐‐task_name=cola \
‐‐do_export=true \
‐‐do_train=true \
‐‐do_eval=true \
‐‐do_predict=false \
‐‐do_lower_case=false \
‐‐data_dir=bert_output \
‐‐export_dir=bert_output \
‐‐label_list=[0, 1] \
‐‐vocab_file=multi_cased_L‐12_H‐768_A‐12/vocab.txt \
‐‐bert_config_file=multi_cased_L‐12_H‐768_A‐12/bert_config.json \
‐‐init_checkpoint=multi_cased_L‐12_H‐768_A‐12/bert_model.ckpt \
‐‐save_checkpoints_steps=5000 \
‐‐iterations_per_loop=500 \
‐‐max_seq_length=128 \
‐‐train_batch_size=32 \
‐‐learning_rate=2e‐5 \
‐‐num_train_epochs=3.0 \
‐‐output_dir=bert_output/
# Feintunen und Export mit Deepset BERT
!python run_new_classifier.py \
‐‐task_name=cola \
‐‐do_export=true \
‐‐do_train=true \
‐‐do_eval=true \
‐‐do_predict=false \
‐‐do_lower_case=false \
‐‐data_dir=bert_output \
‐‐export_dir=bert_output \
‐‐label_list=[0, 1] \
‐‐vocab_file=bert‐base‐german‐cased/vocab.txt \
‐‐bert_config_file=bert‐base‐german‐cased/bert_config.json \
‐‐init_checkpoint=bert‐base‐german‐cased/bert_model.ckpt \
‐‐iterations_per_loop=500 \
‐‐learning_rate=2e‐5 \
‐‐num_train_epochs=3.0 \
‐‐output_dir=bert_output/

1.4. Evaluieren
Beim Feintunen wurden zwei Parameter variiert: max_seq_length und

train_batch_size. Die Ergebnisse der Evaluierung (mit dev.tsv) wurden für
beide Modelle gegenübergestellt:
Google Multilingual BERT Deepset BERT
max_seq_length=128 max_seq_length=128
train_batch_size=32 train_batch_size=32
learning_rate=2e-5 learning_rate=2e-5
num_train_epochs=3.0 num_train_epochs=3.0
eval_accuracy = 0.7703728 eval_accuracy = 0.7875289

eval_loss = 0.58668065 eval_loss = 0.7185015
global_step = 1161 global_step = 1161
loss = 0.5865018 loss = 0.71841705

loss = 0.6909256 loss = 0.86037236

loss = 0.89707816 loss = 1.0262872

1.5. Export
BERT-Modelle werden in der Regel mit Flask und/oder TensorFlow Serving

bereitgestellt und produktiv genutzt. Dafür müssen die Modelle nach
Feintuning zuerst exportiert werden:
# Modellexport für Serving
estimator._export_to_tpu = False
estimator.export_saved_model(FLAGS.export_dir, serving_input_fn)
Die Funktion serving_input_fn definiert den gewünschten Input beim

Serving und kann unterschiedlich ausfallen.
Vergleichend sehen die Modellexporte für Google Multilingual BERT und für
Deepset BERT so aus:
# Exported Model (Google Multilingual BERT)
1
variables
variables.data‐00000‐of‐00001 695 MB
variables.index 9 KB
saved_model.pb 885 KB
vocab.txt 973 KB
# Exported Model (Deepset BERT)
1
variables
variables.data‐00000‐of‐00001 427 MB
variables.index 9 KB
saved_model.pb 884 KB
vocab.txt 249 KB
Die Deepset-BERT Exportdatei ist um ca. 270 MB und die vcab-Datei um

ca. 724 KB kleiner als diese von Google Multilingual BERT.
Inwieweit sich diese Größenunterschiede auf die Performance nach

Bereitstellung auswirken, soll noch geprüft werden.
Für Prognosezwecke können bereits exportierte Modelle wieder geladen

werden (predict_fn):
# Modell für Vorhersagen laden
# wenn nur Flask, ohne TensorFlow Serving
import tensorflow as tf
predict_fn = tf.contrib.predictor.from_saved_model(
os.path.join('dir_to_model', '1'))

1.6. Bereitstellen
Der folgende Code ist eine fast komplette Implementierung der

Bereitstellung der beiden Modelle (Google Multilingual BERT und Deepset
BERT) in Flask:
# Flask app.py
def predict(sentence, url, model_name, tokenizer, max_seq_length,
label_list, labels):
. . .
POST‐Request zu TensorFlow Server
. . .
return label

tokenizer_multi = tokenization.FullTokenizer(
os.path.join('dir_to_vokab_txt',
'vocab.txt'),
do_lower_case=False)
tokenizer_deepset = tokenization.FullTokenizer(
os.path.join('dir_to_vokab_txt',
'vocab.txt'),
do_lower_case=False)

Die predict-Funktion kann das Modell mit predict_fn laden oder aber das
bereits unter TensorFlow Serving gestartete Modell benutzen. Im ersten
Fall wird der Flask-Server stak belastet. Deshalb ist die Variante ohne
Modell Server (TensorFlow Serving) nicht zu empfehlen.
Der Ablauf einer BERT-Webanwendung sieht in etwa wie folgt aus:
1. Javascript POST-Request von der Webanwendung an den Webserver:
# Javascript POST‐Request an den Webserver
var xhr = new XMLHttpRequest();
xhr.open("POST", '/bert_germeval/', true);
xhr.setRequestHeader('content‐type', 'application/x‐www‐form‐
urlencoded;charset=UTF‐8');
xhr.onload = function () {
alert('BERT Tweet‐Bewertung: \n' + xhr.responseText);
};
xhr.send("b64=" + sentence)

2. Webserver-Proxy (Apache) zum RESTful-Server (Flask):
# Apache Proxy zu Flask
<Location "/bert_germeval">
ProxyPass http://localhost:port/bert_germeval
ProxyPassReverse http://localhost:port/bert_germeval
</Location>
3. Flask predict_fn oder POST-Request zum Modell-Server (TensorFlow

Serving):
# Flask app.py
@app.route('/bert_germeval/', methods=['POST'])

def bert_germeval():
data = request.form["b64"]
sentence = data.split('///')
try:
out1 = predict(sentence = sentence[0],
url = "http://localhost:port",
model_name = "GoogleGermEval",
tokenizer = tokenizer_multi,
max_seq_length = 128,
label_list = [0, 1],
labels = ["nicht beleidigend", "beleidigend"])
out2 = predict(sentence = sentence[0],
url = "http://localhost:port",
model_name = "DeepsetGermEval",
tokenizer = tokenizer_deepset,
max_seq_length = 128,
label_list = [0, 1],
labels = ["nicht beleidigend", "beleidigend"])

return jsonify({'Google BERT' :out1,'Deepset BERT' :out2})

except Exception as e:
print(e)
return jsonify({"Ergebnis":"Fehler im Modell"})
Die Performance (Antwortzeit) wurde für beide Modelle auf einem Ubuntu
16.04 Server untersucht. Es konnten keine Unterschiede festgestellt
werden. Die Antwortzeit beträgt ca. 1s.

Alles das vergleichend für beide Modelle (Google Multilingual und Deepset
BERT) kann live auf der Webseite https://next-rtc.com getestet werden.

2. German News Topic Prediction
Abstract
Nachrichten sind in der Regel Kurztexte. Mit Google BERT versuchen wir
deutschsprachige Nachrichten aufgrund der ersten 512 Wörter (Token) zu
thematisieren (German news topic prediction).
Für unsere Untersuchungen haben wir das "German News Articles

Dataset" (10kGNAD) verwendet. Das Projekt sucht u.a. nach
Möglichkeiten, deutschsprachige Nachrichten automatisch zu
thematisieren – hier 9 Themen: 'Etat', 'Inland', 'International', 'Kultur',
'Panorama', 'Sport', 'Web', 'Wirtschaft', 'Wissenschaft' (Schabus et al.
2017).
Die Prognosegenauigkeit beim Thematisieren von deutschsprachigen

Nachrichten aufgrund der ersten 512 Wörter (Token) beträgt mit Deepset
BERT 90,6% und mit Google Multilingual BERT 89,2%. Damit schneidet
Deepset BERT mit ca. 1,4% besser ab.
Das feinjustierte Deepset BERT-Modell wurde ins Internet bereitgestellt.

Die Antwortzeit auf einem Ubuntu 16.04 Server beträgt ca. 1s.
2.1. Einführung
Mit Google BERT - Bidirectional Encoder Representations from

Transformers (Devlin et al. (2019) kann man Texte bis maximal 512
Wörter (Token) bearbeiten. Deutschsprachige Nachrichten sind aber
wesentlich länger.
Mit Google BERT versuchen wir deutschsprachige Nachrichten aufgrund

der ersten 512 Wörter (Token) zu thematisieren (German news topic
prediction).

BERT-Modell. Nach unseren vergleichenden Untersuchungen haben wir
uns für Deepset-BERT entschieden:
https://deepset.ai/german-bert.

Im Weiteren setzen wir ausschließlich auf TensorFlow BERT:
mit TensorFlow Serving:
2.2. Daten
Für unsere Untersuchungen haben wir "German News Articles Dataset"

(10kGNAD) verwendet:
https://tblock.github.io/10kGNAD/.
Das Projekt sucht u.a. nach Möglichkeiten, Nachrichten automatisch zu

thematisieren - 9 Themen: 'Etat', 'Inland', 'International', 'Kultur',
2017).
Das Trainingsdatenset (train.tsv) betrug gut 10.273 Nachrichten. Das

Evaluierungsdatenset (dev.tsv) bestand aus gut 1.027 Nachrichten. Beide
Datensets enthielten gelabelte (thematisierte) deutschsprachige
Nachrichten.

2.3. Feintunen, Evaluieren und Bereitstellen
Das Feintunen (train.tsv) mit Deepset BERT erfolgte mit Google Colab
(GPU) auf Google Drive.
Die Ergebnisse der Evaluierung (dev.tsv) mit Deepset BERT wurden wie
folgt zusammengestellt:
Deepset BERT Google Multilingual BERT

loss = 0.49110138 loss = 0.5109123
Die Prognosegenauigkeit beim Thematisieren von deutschsprachigen

Nachrichten aufgrund der ersten 512 Wörter (Token) beträgt mit Deerpset
BERT 90,6% und mit Google Multilingual BERT 89,2%. Damit schneidet
Deepset BERT mit ca. 1,4% besser ab.
Das so feinjustierte BERT-Modell wurde exportiert und ins Internet

bereitgestellt.

Es kann auch live auf der Webseite https://next-rtc.com getestet werden:

3. German Customer Posts Sentiment Prediction
Abstract
Kundenposts sind nicht immer Kurztexte. Mit Google BERT versuchen wir
die Kundenstimmung aus Posts über die Deutsche Bahn aufgrund der
ersten 512 Wörter (Token) zu klassifizieren.
Für unsere Untersuchungen haben wir den GermEval 2017 Datensatz

verwendet. Das Projekt sucht nach Möglichkeiten, Posts über die Deutsche
Bahn aus den sozialen Netzwerken in 3 Kategoriern automatisch zu
bewerten: 'negativ', 'neutral' oder 'positiv'.
Die Prognosegenauigkeit der Kundenstimmung von deutschsprachigen

Posts (Deutsche Bahn) aufgrund der ersten 512 Wörter (Token) beträgt
mit Deepset BERT 80,5% und mit Google Multilingual BERT 79,6%. Damit
schneidet Deepset BERT mit ca. 0,85% besser ab.
Das feinjustierte Deepset BERT-Modell wurde ins Internet bereitgestellt.

Die Antwortzeit auf einem Ubuntu 16.04 Server beträgt ca. 1s.
3.1. Einführung
Mit Google BERT - Bidirectional Encoder Representations from

Transformers (Devlin et al. (2019) kann man Texte bis maximal 512
Wörter (Token) bearbeiten. Deutschsprachige Posts sind aber oft
wesentlich länger.
Mit Google BERT versuchen wir die Kundenstimmung aus Posts über die
Deutsche Bahn aufgrund der ersten 512 Wörter (Token) zu klassifizieren.

BERT-Modell. Nach unseren vergleichenden Untersuchungen haben wir
uns für Deepset-BERT entschieden:

Im Weiteren setzen wir ausschließlich auf TensorFlow BERT:
mit TensorFlow Serving:
3.2. Daten

verwendet:
https://sites.google.com/view/germeval2017-absa/data
Das Projekt sucht nach Möglichkeiten, Posts über die Deutsche Bahn aus
den sozialen Netzwerken in 3 Kategoriern automatisch zu bewerten:
'negativ', 'neutral' oder 'positiv'.
Das Trainingsdatenset (train.tsv) betrug gut 20.000 Posts. Das

Evaluierungsdatenset (dev.tsv) bestand aus gut 2.000 Posts.

3.3. Feintunen, Evaluieren und Bereitstellen
Das Feintunen (train.tsv) mit Deepset BERT erfolgte mit Google Colab
(GPU) auf Google Drive.
Die Ergebnisse der Evaluierung (dev.tsv) mit Deepset BERT wurden wie
folgt zusammengestellt:
Deepset BERT Google Multilingual BERT

loss = 0.92898977 loss = 0.8370954
Die Prognosegenauigkeit der Kundenstimmung von deutschsprachigen

Posts (Deutsche Bahn) aufgrund der ersten 512 Wörter (Token) beträgt
mit Deepset BERT 80,5% und mit Google Multilingual BERT 79,6%. Damit
schneidet Deepset BERT mit ca. 0,85% besser ab.
Das so feinjustierte BERT-Modell wurde exportiert und ins Internet

bereitgestellt.

Es kann auch live auf der Webseite https://next-rtc.com getestet werden:

4. German BERT Sentence Embeddings
Abstract
Eine Möglichkeit, Texte miteinander zu vergleichen, ist diese Texte in

Vektoren gleicher Länge umzuwandeln. Die Vektoren kann man dann
mathematisch vergleichen und dadurch die semantische Ähnlichkeit der
Texte messen.
Bert-as-a-service kann für Textklassifikation und QA eingesetzt werden.

Texte werden mit dem ungetunten Deepset BERT-Modell vektorisiert
(BERT Sentence Embeddings) und aufgrund der Ähnlichkeit klassifiziert.
Ein QA-Beispiel dafür wäre die richtige Antwort aus einer Menge
vorgegebener Frage/Antwort-Paare automatisch herauszufinden (FAQ
Bot).
Nachrichten thematisieren ist ein anderes Beispiel, indem wir das

ungetunte Deepset BERT-Modell mit wenigen gelabelten Nachrichten für
die Themen-Prognose (topic prediction) eingesetzt haben.
Die Kundenstimmung aus Posts messen, ist eine für viele Unternehmen
wichtige Anwendung. Mit 100-200 gelabelten Posts kann bereits gestartet
werden (Kundenstimmung messen).
Die Performance beim Serving ist sehr gut, da das Laden der Dateien ein
einmaliger Vorgang ist (beim Starten der Server). Die Antwortzeit auf
einem Ubuntu 16.04 Server beträgt ca. 1s.
Kurztexte können mit BERT in Sentence Embeddings vektorisiert und auf

verschiedene Merkmale (Labels) regressiert werden. Die so geschätzten
Regressionsmodelle können wiederum für Prognosen genutzt werden.
Bert-as-a-service mit Deepset BERT klassifizierten besser

deutschsprachige Kurztexte als Wikipedia2Vec.

4.1. Semantische Ähnlichkeit
Eine Möglichkeit, Texte miteinander zu vergleichen, ist diese Texte in

Vektoren gleicher Länge umzuwandeln (codieren). Die Vektoren kann man
dann mathematisch vergleichen (nearest neighbor search)
https://en.wikipedia.org/wiki/Nearest_neighbor_search
und dadurch die semantische Ähnlichkeit der Texte messen. Dafür gibt es
verschiedene Verfahren:
Der euklidische Abstand der Vektoren q und p wird wie folgt berechnet
und ist als Abstand zweier Punkte im n-dimensionalen Koordinatensystem

zu verstehen:
Der euklidische Abstand ist schwer interpretierbar. Dafür eignet sich mehr
die euklidische Ähnlichkeit (s).

Die Ähnlichkeit (s – similarity) der Vektoren A und B kann vergleichend so
ermittelt werden:
Dabei gilt -1 =< s <= 1, von s = -1 (genau das Gegenteil) bis s = 1

(genau gleich). Für s = 0 ist keine Ähnlichkeit vorhanden.
Numerisch entspricht s dem Korrelationskoeffizienten r zwischen

A und B (s ~ r). Die Deutung ist aber eine ganz andere.
Für die Vektorisierung der Texte (BERT Sentence Embeddings) setzten

wir Bert-as-a-service
https://github.com/hanxiao/bert-as-service
mit dem ungetunten Deepset BERT-Modell ein:

4.2. Texte vergleichen
Es werden 2 beliebige Texte eingegeben und automatisch vektorisiert. Als

Maß für die Ähnlichkeit der beiden Texte wird der euklidische Abstand und
die euklidische Ähnlichkeit der beiden Vektoren berechnet und angezeigt.
Der Ablauf dieser Bert-as-a-service Webanwendung sieht in etwa wie folgt

aus:
1. Javascript POST-Request von der Webanwendung an den Webserver:
xhr.open("POST", '/bert_service_encoder/', true);
res = xhr.responseText;
res = res.split("///");
alert("Text 1: " + sentence1 + "\nText 2: " + sentence2 +
"\n\nEuklidischer Abstand = " + res[0] +
"\n\nEuklidische Ähnlichkeit = " + res[1]);
};
xhr.send("b64=" + sentence1 + ‘///’ + sentence2);
2. Webserver-Proxy (Apache) zum RESTful-Server (Flask):
<Location "/bert_service_encoder ">
ProxyPass http://localhost:port/bert_service_encoder
ProxyPassReverse http://localhost:port/bert_service_encoder
</Location>

3. Und unter Flask die BertClient-Funktion oder POST-Request zum
BERT Serving-Server benutzen:
# Flask app.py
from bert_serving.client import BertClient
bc = BertClient(port=port, port_out=port_out)

@app.route('/bert_service_encoder/', methods=['POST'])

def bert_service_encoder():

texts = [sentence[0], sentence[1]]

try:
vec_bc = bc.encode(texts, is_tokenized=False)
vec1 = vec_bc[0]
vec2 = vec_bc[1]

#payload = {"id": 123,"texts": texts,
"is_tokenized": False}
#req = requests.post('http://localhost:port/encode',
json=payload)
#pred = json.loads(req.content.decode('utf‐8'))
#vec1 = np.array(pred['result'][0])
#vec2 = np.array(pred['result'][1])

distance = np.sqrt(np.sum((vec1 ‐ vec2)**2))
similarity = np.sum(vec1*vec2)/
(np.sqrt(np.sum(vec1**2))*np.sqrt(np.sum(vec2**2)))

ret = str(distance) + '///' + str(similarity)
return ret

print(e)
Die Performance (Antwortzeit) wurde auf einem Ubuntu 16.04 Server

untersucht. Die Antwortzeit beträgt ca. 1s.

Wie Bert-as-a-service wirklich funktioniert, kann live auf der Webseite
https://next-rtc.com getestet werden:

4.3. FAQ Geldwäsche
Unsere Beispiel-FAQ's haben wir aus dem wirtschaftlich sehr bedeutenden

Bereich der Geldwäsche übernommen:
https://bankenverband.de/fachthemen/steuern/fragen-und-antworten-
zum-thema-geldwaesche/
Und so funktioniert es: Die gestellte Frage wird mit allen FAQ-Fragen
verglichen und die FAQ-Antwort der FAQ-Frage mit der größten
Ähnlichkeit mit der gestellten Frage wird angezeigt.
- Datenstruktur (faq.tsv):
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# id Frage Antwort
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# sep = '\t'
# header=False
- Javascript POST-Request an den Webserver:
xhr.open("POST", '/bert_faq_encoder/', true);
alert(frage + '\n\n' + res[1]);
};
xhr.send("b64=" + frage);
- Webserver-Proxy (Apache) zum RESTful-Server (Flask):
<Location "/bert_faq_encoder ">
ProxyPass http://localhost:port/bert_faq_encoder
ProxyPassReverse http://localhost:port/bert_faq_encoder
</Location>

- Und unter Flask die BertClient-Funktion zum BERT Serving-Server
benutzen:
# Flask app.py

faq = pd.read_csv('/dir_to/faq.tsv', sep = '\t',
header=None,
encoding='latin1')
faq_sentences = []
for i in range(1,len(faq)+1):
faq_sentences.append(faq[1][i‐1])
doc_vecs = bc.encode(faq_sentences)

@app.route('/bert_faq_encoder/', methods=['POST'])

def bert_faq_encoder():

try:
query_vec = bc.encode([sentence[0]])[0]

score = np.sum(query_vec * doc_vecs, axis=1)/
(np.linalg.norm(query_vec)*
np.linalg.norm(doc_vecs, axis=1)
topk_idx = np.argsort(score)[::‐1][:1]
for idx in topk_idx:
ret = str(score[idx]) + '///' + str(faq[2][idx])
return ret

print(e)


untersucht. Die Antwortzeit ist < 1s.

Wie die FAQ Beispielanwendung wirklich funktioniert, kann live auf der
Webseite https://next-rtc.com getestet werden:

4.4. FAQ Coronavirus
Unsere Beispiel-FAQ's zum Coronavirus haben wir dem folgenden Link

entnommen (Stand 30.08.2020):
https://www.focus.de/gesundheit/news/titelthema-sars-cov-2-
zwischenbilanz-einer-pandemie_id_12343424.html
Und so funktioniert es: Die gestellte Frage wird mit allen FAQ-Fragen
verglichen und die FAQ-Antwort der FAQ-Frage mit der größten
Ähnlichkeit mit der gestellten Frage wird angezeigt.
- Datenstruktur (faq_corona.tsv):
# id Frage Antwort
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# sep = '\t'; header=False
xhr.open("POST", '/bert_faq_corona_encoder/', true);
alert(frage + '\n\n' + res[1]);
};
xhr.send("b64=" + frage);
<Location "/bert_faq_corona_encoder ">
ProxyPass http://localhost:port/bert_faq_corona_encoder
ProxyPassReverse http://localhost:port/bert_faq_corona_encoder
</Location>

benutzen:
# Flask app.py

faq_corona = pd.read_csv('/dir_to/faq_corona.tsv', sep = '\t',
header=None,
encoding='latin1')
faq_corona_sentences = []
for i in range(1,len(faq_corona)+1):
faq_corona_sentences.append(faq_corona[1][i‐1])
doc_vecs = bc.encode(faq_corona_sentences)

@app.route('/bert_faq_corona_encoder/', methods=['POST'])

def bert_faq_corona_encoder():

try:

ret = str(score[idx]) + '///' + str(faq_corona[2][idx])
return ret

print(e)



Wie die FAQ Beispielanwendung zum Coronavirus wirklich funktioniert,
kann live auf der Webseite https://next-rtc.com getestet werden:

4.5. Nachrichten thematisieren
Für unsere Untersuchungen haben wir "German News Articles Dataset"

(10kGNAD) verwendet:
https://tblock.github.io/10kGNAD/.
Das Projekt sucht u.a. nach Möglichkeiten, Nachrichten automatisch zu

thematisieren - 9 Themen: 'Etat', 'Inland', 'International', 'Kultur',
2017).
Der Datensatz enthält 10.273 bereits thematisierte deutschsprachige

Nachrichten. Davon haben wir lediglich die ersten 200 Nachrichten
verwendet.
Und so funktioniert es: Ihre Nachricht wird mit allen thematisierten

Nachrichten verglichen und das Thema (Topic) der Nachricht mit der
größten Ähnlichkeiten mit Ihrer Nachricht wird angezeigt.
xhr.open("POST", '/bert_news_encoder/', true);
alert('Thema: ' + res[1] + '\n\n' + news);
};
xhr.send("b64=" + news);
<Location "/bert_news_encoder ">
ProxyPass http://localhost:port/bert_news_encoder
ProxyPassReverse http://localhost:port/bert_news_encoder
</Location>

benutzen:
# Flask app.py

news = pd.read_csv('/dir_to/train.tsv', sep = '\t',
header=None,
encoding='latin1')
news_sentences = []
for i in range(1,len(news)+1):
news_sentences.append(news[1][i‐1])
doc_vecs = bc.encode(news_sentences)

@app.route('/bert_news_encoder/', methods=['POST'])

def bert_news_encoder():

try:

ret = str(score[idx]) + '///' + str(news[2][idx])
return ret

print(e)



Wie die Thematisierung wirklich funktioniert, kann live auf der Webseite
https://next-rtc.com getestet werden:

4.6. Kundenstimmung messen

verwendet:
https://sites.google.com/view/germeval2017-absa/data
Das Projekt sucht nach Möglichkeiten, Posts über die Deutsche Bahn aus
den sozialen Medien in 3 Kategoriern automatisch zu bewerten: 'negativ',
'neutral' oder 'positiv'.
Der Datensatz enthält zusammen 22.000 gelabelte, deutschsprachige

Posts. Davon haben wir lediglich die ersten 100 Posts verwendet.
Und so funktioniert es: Ihre Bewertung wird mit allen gelabelten

Bewertungen (Posts) verglichen und die Stimmung (Sentiment) der
Bewertung mit der größten Ähnlichkeiten mit Ihrer Bewertung wird
angezeigt.
xhr.open("POST", '/bert_posts_encoder/', true);
alert('Stimmung: ' + res[1] + '\n\n' + posts);
};
xhr.send("b64=" + posts);
<Location "/bert_posts_encoder ">
ProxyPass http://localhost:port/bert_posts_encoder
ProxyPassReverse http://localhost:port/bert_posts_encoder
</Location>

benutzen:
# Flask app.py

posts = pd.read_csv('/dir_to/train.tsv', sep = '\t',
header=None,
encoding='latin1')
posts_sentences = []
for i in range(1,len(posts)+1):
posts_sentences.append(posts[1][i‐1])
doc_vecs = bc.encode(posts_sentences)

@app.route('/bert_posts_encoder/', methods=['POST'])

def bert_posts_encoder():

try:

labels=['negativ', 'neutral', 'positiv']
ret = str(score[idx]) + '///' + str(labels[posts[1][idx]])
return ret

print(e)



Wie die Stimmungsbewertung wirklich funktioniert, kann live auf der
Webseite https://next-rtc.com getestet werden:

4.7. Semantische Suche
Filme nach Inhalt suchen: Für diese Untersuchungen kann man Stanford
IMDB-Dataset
http://www.cs.cmu.edu/~ark/personas/
und natürlich ein englischsprachiges BERT-Modell verwenden.
Für die semantische Suche sind Name und Inhalt der Filme von
Bedeutung. Die Inhalte aller Filme werden mit Bert-as-a-service
vektorisiert. Sie haben beispielsweise den Film „Indiana Jones and the
Raiders of the Lost Ark” gesehen und möchten weitere Filme mit einem
ähnlichen Inhalt sehen.
Und so funktioniert es: Es wird der vektorisierte Inhalt dieses Films mit
allen anderen verglichen und die Namen der Filme mit der größten
Ähnlichkeit mit „Indiana Jones and the Raiders of the Lost Ark” werden
angezeigt:

4.8. Regressionsmodelle
Kurztexte können mit BERT in Vektoren gleicher Länge (BERT Sentence

Embeddings) codiert und auf verschiedene Merkmale (Labels) regressiert
werden. Die so geschätzten Regressionsmodelle können wiederum für
Prognosen genutzt werden.
4.8.1. Multiple lineare Regression
Regressionsmodell (1) für kontinuierliche Merkmale (keine Labels):
y = Xβ + e (1)
Dabei ist X eine (n x 768) Matrix der BERT Sentence Embeddings

(vektorisierte Kurztexte) und y – (n x 1) Vektor der abhängigen
(kontinuierlichen) Variable und β – die zu schätzenden
Regressionskoeffizienten (768 x 1). Nach der Methode der Kleinsten
Quadrate werden die Regressionskoeffizienten wie folgt geschätzt:
b = (X'X)-1 X'y (2)
Die Schätzung/Prognose (3) für einen konkreten Wert y der abhängigen

Variable y (Merkmalsvariable) berechnet man nach
y = xb (3)
wobei x der (1 x 768) Vektor der BERT Sentence Embeddings eines

konreten Kurztextes (max. 512 Token) und b der (768 x 1) Vektor der
nach (2) geschätzten Regressionskoeffizienten sind.
Als Maß für die Prognosegenauigkeit dient hier das Bestimmtheitsmaß R%

(der prozentualle Anteil der durch die Regression erklärte Varianz der
abhängigen Variable).

4.8.2. Logistische Regression/Klassifikation
Binomiale logistische Regression - Regressionsmodell für binäre

Variablen (Labels). Damit sind zwei Ausprägungen/Labels gemeint (y=1,
y=0):
p(y=1) = 1/(1 + e-z),
wobei p(y=1) die Wahrscheinlichkeit für Label=1 und z die

Regressionsfunktion einer multiplen linearen Regression darstellen.
Ein Beispiel hierfür wäre die Sentiment-Analyse mit den beiden Labels
negativ = 0 und positiv = 1 oder die Tweet-Bewertung in 0 – nicht
beleidigend und 1 - beleidigend.
Multinomiale logistische Regression - Regressionsmodell für multiple

Ausprägungen (Labels):
Es handelt sich um eine spezielle Form der logistischen Regression, bei

der die abhängige Variable y mehr als zwei Ausprägungen (Labels) haben
darf. Dabei wird für jede der Ausprägungen ein eigenes Regressionsmodell
ausgegeben.
Ein Beispiel dafür wäre „Nachrichten thematisieren“ mit 9 Themen/Labels.
4.8.3. Lasso und Ridge Regression
Wenn die Anzahl der Datensätze gering im Vergleich zu der Anzahl der
unabhängigen Variablen ist (n<<768), entsteht eine Überanpassung und
dadurch eine Verzerrung der Erbenisse. In solchen Fällen liefern
Regressionsmodelle mit Regularisierung (zusätzliche Bedingung zu der
Verlustfunktion der Regression) wesentlich bessere Schätzgenauigkeit als
Regressionen ohne Regularisierung. Dazu gehören die Lasso Regression
(L1-Regularisierung)
und die Ridge Regression (L2-Regularisierung)

4.8.4. Regression mit Scikit-learn
Scikit-learn ist eine freie Software-Bibliothek zum maschinellen

Lernen für die Programmiersprache Python. Damit können auch die oben
beschrienen Regressionsmodelle mit echten Daten eingesetzt werden:
# Beispiel für Lineare Regression

import pandas as pd
df = pd.read_csv('/dir_to/train.tsv', sep = '\t',
header=None,
encoding='latin1')
sentences = []
y = []
n = ...
for i in range(0, n):
sentences.append(df[2][i])
y.append(df[1][i])
X = bc.encode(sentences)

from sklearn import linear_model
reg = linear_model.LinearRegression()
reg.fit(X, y)

new_sentence = 'In seiner erst zweiten Saison konnte Leclerc ' +
'der Formel 1 bereits seinen Stempel aufdrücken.'
x = bc.encode(new_sentence)

y_predicted = reg.predict(x)

# Beispiel für Binomiale und Multinomiale Regression (Klassifikation)
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

reg = LogisticRegression()
reg.fit(train_X, train_y)

# Klassifikationsgüte
print("Genauigkeit: %f" % accuracy_score(test_y, reg.predict(test_X)))

5. Fine-tuning vs. Sentence Embeddings
Unter Feintuning versteht man eine aufgabenrelevante Feinabstimmung

des vorab trainierten BERT-Modells. Ein praktisches Beispiel dafür ist das
Thematisieren deutschsprachiger Nachrichten aus Abschnitt 2.
BERT Word Embeddings sind bidirektional kontextabhängig im Vergleich

zu den kontextlosen word2vec und GloVe. Ein gutes Beispiel dafür ist das
Wort Bank. Nach word2vec und GloVe gibt es keinen Unterschied zwischen
der Bank als Finanzinstitut und der Bank im Park. Bidirektional
kontextabhängig bedeutet, dass der Text links und rechts des Wortes
Bank zu unterschiedlichen Embeddings führen kann.
BERT Sentence Embeddings sind mit Bert-as-a-service (Pooling-Strategie

und –Schichten) vektorisierte Texte, die auch zusammengehören könnten,
wie etwa Frage und Antwort. Als Maß für die Zusaammengehörigkeit
zweier Texte kann die euklidische Ähnlichkeit derer Vektoren, bzw. derer
Embeddings dienen. Ein praktisches Beispiel dafür ist das Thematisieren
deutschsprachiger Nachrichten aus Abschnitt 4.5. Die Ergebnisse sind
nahezu identisch.
Die Sentimentbestimmung von Kundenposts der Deutschen Bahn fällt

dagegen nach Feintuning (Abschnitt 3.) besser aus, als die embeddings-
basierte aus Abschnitt 4.6.
Eine mögliche Erklärung finden wir im verwendeten BERT-Modell, hier

Deepset BERT:
https://deepset.ai/german-bert
Das Modell wurde zu 30% mit deutschsprachigen Nachrichten vorab

trainiert. Dadurch fallen die Sentence Embeddings der Nachrichten
deutlich „besser“ als diese der Kundenposts aus.
Um diese Annahme zu überprüfen, haben wir das Feintunen der beiden

Modelle (Nachrichten und Kundenposts) mit den jeweils 200 ersten
Datensätzen durchgeführt und die Evaluierungsgenauigkeit mit der aus
den Abschnitten 2. und 3. verglichen:

Nachrichten thematisieren Kundenposts klassifizieren
N = 10.273 (alle Datensätze) N = 20.000 (alle Datensätze)


loss = 0.49110138 loss = 0.9457743
N = 200 Datensätze N = 200 Datensätze


loss = 0.6009925 loss = 0.7466168
Das Feintunen mit den ersten 200 Nachrichten ergibt eine um 0,8%
niedrigere Genauigkeit der Prognose gegenüber der Variante mit allen
Datensätzen.
Dagegen liegt die Prognosegenauigkeit beim Klassifizieren der

Kundenstimmung nach Feintunen mit den ersten 200 Kundenposts um
1,1% niedriger im Vergleich zum Modell mit allen Datensätzen.
Dieses Ergebnis unterstützt unsere Annahme, dass das Deepset BERT-

Modell deutschsprachige Nachrichten etwas besser klassifiziert, und zeigt
darüber hinaus, dass auch Nachtrainieren mit ungelabelten Daten zu einer
höheren Prognosegenauigkeit führt.

6. Pre-training with BERT
Abstract
Das BERT-Modell kann mit ungelabelten deutschsprachigen Daten
von Grund auf neu trainiert oder ein bereits vortrainiertes Modell
nachtrainiert werden.
Die Vorgehensweise ist in beiden Fällen identisch. Da Pre-training

grundsätzlich je nach Datenmenge auch mehrere Tage Rechenleistung in
Anspruch nehmen kann, lohnt sich das Nachtrainieren eines bereits
vortrainierten BERT-Modells.
Aus unseren vergleichenden Untersuchungen geht deutlich hervor, dass

Deepset BERT für das Nachtrainieren mit problem-orientierten Daten gut
geeignet ist.
ClinicalBert (Huang et al., 2019) ist ein Basis-BERT-Modell, das von Grund
auf mit englischsprachigen klinischen Daten vortrainiert wurde.
Deutschsprachige klinische Daten können für die Entwicklung eines

deutschaprachigen BERT-Modells verwendet werden. Dabei sind Pre-
training (von Grund auf) oder das Nachtrainiren von Deepset Bert
möglich.
FinBert (Yang et al. 2020) ist ein Basis-BERT-Modell, das von Grund auf
mit englischsprachigen Geschäftsberichten (Jahres- und Quartalsberichte
– 10-K und 10-Q) der amerikanischen SEC (Securities Exchange
Commission) vortrainiert wurde.
Deutschsprachige Geschäftsberichte aus dem Bundesanzeiger können für

die Entwicklung eines deutschaprachigen BERT-Modells verwendet
werden. Dabei sind Pre-training (von Grund auf) oder das Nachtrainiren
von Deepset Bert möglich.

6.1. Two kinds of Pre-training
Das BERT-Modell kann mit ungelabelten deutschsprachigen Daten

von Grund auf neu trainiert oder ein bereits vortrainiertes Modell
nachtrainiert werden:
Die Vorgehensweise ist in beiden Fällen identisch. Da Pre-training

grundsätzlich je nach Datenmenge auch mehrere Tage Rechenleistung in
Anspruch nehmen kann, lohnt sich das Nachtrainieren eines bereits
vortrainierten BERT-Modells.
Aus unseren vergleichenden Untersuchungen geht deutlich hervor, dass

Deepset BERT (https://deepset.ai/german-bert) für das Nachtrainieren
mit problem-orientierten Daten gut geeignet ist.
Zuerst müssen die Daten in Unicode-Format (UTF-8) vorbereitet werden –

eine Sentence pro Zeile. Die GermEval-Daten train.tsv (gut 12.000
Tweets) aus Abschnitt 1.2 könnten wie unten angezeigt in eine pre-
training.txt Datei gespeichert werden:
import pandas as pd
input_file = 'germeval/train.tsv'
output_file = 'germeval/pre‐training.txt'

df = pd.read_csv(input_file, sep = '\t', header=None, encoding='latin1')
df[3].to_csv(output_file, sep = '\t', index=False, header=False)
Und mithilfe der folgenden Funktion in Tfrecord-Format überführt werden:
!python create_pretraining_data.py \
‐‐input_file=germeval/pre‐training.txt \
‐‐output_file=germeval/tf_pre_training.tfrecord \
‐‐vocab_file=bert‐base‐german‐cased/vocab.txt \
‐‐do_lower_case=False \
‐‐max_predictions_per_seq=77 \
‐‐masked_lm_prob=0.15 \
‐‐random_seed=12345 \
‐‐dupe_factor=5

Mit den so vorbereiteten Daten kann das Nachtrainieren von Deepset
BERT beginnen:
!python run_pretraining.py \
‐‐input_file=germeval/tf_pre_training.tfrecord \
‐‐output_dir=bert_output \
‐‐do_train=True \
‐‐do_eval=True \
‐‐bert_config_file=bert‐base‐german‐cased/bert_config.json \
‐‐init_checkpoint=bert‐base‐german‐cased/bert_model.ckpt \
‐‐max_predictions_per_seq=77 \
‐‐num_train_steps=20000 \
‐‐num_warmup_steps=2000 \
‐‐learning_rate=2e‐5
Welche Bedeutung die einzelnen Parameter haben und wie diese gewählt
werden sollen, ist im „Abschnitt Pre-training with BERT“ dem folgenden
Link https://github.com/google-research/bert zu entnehmen.
Erst nach 20.000 training steps (global_step = 20.000) ist die erreichte
Genauigkeit hoch genug (96,8%).
global_step = 1.000 global_step = 5.000

loss = 2.3311088 loss = 1.4472977
masked_lm_accuracy = 0.62238634 masked_lm_accuracy = 0.7055844
masked_lm_loss = 1.9648762 masked_lm_loss = 1.444803
next_sentence_accuracy = 0.84875 next_sentence_accuracy = 0.99875
next_sentence_loss = 0.36623234 next_sentence_loss = 0.0024951831
global_step = 10.000 global_step = 20.000

loss = 0.81035227 loss = 0.16330622
masked_lm_accuracy = 0.8216072 masked_lm_accuracy = 0.96829545
masked_lm_loss = 0.81030256 masked_lm_loss = 0.1633054
next_sentence_accuracy = 1.0 next_sentence_accuracy = 1.0
next_sentence_loss = 4.976038e-05 next_sentence_loss = 8.563559e-07
Nach dem Pre-training mit den GermEval-Daten kann Deepset BERT auch
noch zusätzlich mit gelabelten Daten feingetunt werden.

6.2. Domain-specific BERT Models
Von Grund auf neu vortrainierte domänenspezifische BERT-Modelle

(englischsprachig) finden bereits eine breite Anwendung:
 BioBERT (Devlin et al., 2019)
 ClinicalBERT (Huang et al., 2019)
 SciBERT (Beltagy et al., 2019)
 FinBERT (Yang et al., 2020)
6.3. Domain-specific German BERT Applications
Ähnlich können auch deutschsprachige BERT-Modelle vortrainiert werden.

Deepset BERT kann aber auch wie bereits gezeigt domänenspezifisch
nachtrainiert und/oder feingetunt werden.
6.3.1. German ClinicalBERT
ClinicalBert (Huang et al., 2019) ist ein Basis-BERT-Modell, das von Grund
auf mit englischsprachigen klinischen Daten vortrainiert wurde.
Deutschsprachige klinische Daten können für die Entwicklung eines

deutschaprachigen BERT-Modells verwendet werden. Dabei sind Pre-
training (von Grund auf) oder das Nachtrainiren von Deepset Bert
möglich.
6.3.2. German FinBERT
FinBert (Yang et al. 2020) ist ein Basis-BERT-Modell, das von Grund auf
mit englischsprachigen Geschäftsberichten (Jahres- und Quartalsberichte
– 10-K und 10-Q) der amerikanischen SEC (Securities Exchange
Commission) vortrainiert wurde.

Deutschsprachige Geschäftsberichte aus dem Bundesanzeiger
https://publikations-
plattform.de/sp/wexsservlet?global_data.designmode=pp&page.navid=to
_start&dest=wexsservlet&global_data.language=de#b
können für die Entwicklung eines deutschaprachigen BERT-Modells

verwendet werden. Dabei sind Pre-training (von Grund auf) oder das
Nachtrainiren von Deepset Bert möglich.

7. Company knowledge on Demand
Firmenwissen mit Google BERT in Echtzeit verfügbar machen. Dafür gibt

es mehrere Szenarien:
1. Das BERT-Modell mit ungelabelten Firmendaten (z.B. Wikis)
nachtrainieren (Pre-training with BERT). Dieser Vorgang kann je
nach Datenmenge auch einige Tage Rechenleistung in Anspruch
nehmen.
2. Das BERT-Modell mit gelabelten Firmendaten feintunen und
bereitstellen (Abschnitt 1-3).
3. BERT Sentence Embeddings (Bert-as-a-service) für die
Wissenssuche verwenden (Abschnitt 4).
8. Multilingual BERT Applications
Mehrsprachige BERT-Anwendungen können mit Multilingual BERT

umgesetzt werden (Abschnitt 1-3). Ein gleichzeitiger Einsatz
verschiedensprachiger BERT-Modelle, wie z.B. Deepset BERT und Google
BERT-Base sind auch denkbar und leicht umsetzbar. Es muss aber in
jedem Einzelfall abgewogen werden. Hier ein konkretes Beispiel:
Deutsch- und englischsprachig gelabelte Daten liegen vor und können für
eine Feinabstimmung sowohl von Google Multilingual BERT als auch für
Deepset BERT und Google BERT-Base verwendet werden. Diese Daten
können aber auch für Anwendungen mit Bert-as-a-service (Abschnitt 4)
genutzt werden.
Die gleichzeitge Nutzung verschiedensprachiger BERT-Modelle ist Google

Multilingual BERT vorzuziehen, da die einsprachigen Modelle etwas
„genauer“ sind. Eine gleichzeitige Bereitstellung verschiedener BERT-
Modelle mit TensorFlow Serving ist auch problemlos möglich (Abschnitt
1.6).

9. contactApps Datenverwaltung in Textdateien
Stand: Daten werden in relationalen Datenbanken unterschiedlicher

Dimension (von SQLite bis Oracle, SAP HANA und Salesforce) verwaltet.
Unterschiede in SQL, Zugriffsreche und Datenbankverwaltung erschweren
Einsatz und Portierung auf verschiedenen Plattformen.
contactApps verwaltet beliebig große Texte nach Kategorien (Kurztexte

bis 512 Wörter/Token - beide Plaintexte) in Textdateien (.tsv):
contactAppsRecord = Kurztext + '\t' + Text + '\n'
Text: End-to-end – Verschlüsselung (optional)

Kurztext: Metadaten, unverschlüsselt
Diese Datenstruktur ist besonders für Deep Learning Modelle im Bereich

NLP (Google BERT) gut geeignet:
- Klassifikationsmodelle: Kurztext = Label
- Semantische Ähnlichkeit: Kurztext = Frage, Text = Antwort
contactAppsTable: Der Dateiname einer Textdatei hat eine feste

Erweiterung, die s.g. contactApps-Id oder kurz Kontakt-Id - z.B.
contact_Kontakt-Id.tsv.
Kontakt-Id: Passwort (optional)
contactAppsField: Im Unterschied zu der relationalen Datenbank

werden Felder und keine Spalten verwaltet. Ein Feld besteht aus
Feldnamen (contactAppsFieldName) bzw. Feldnummer
(contactAppsFieldNo - laufende Nummer in einer Feldtabelle) und
Feldwert (contactAppsFieldValue). Der wesentliche Unterschied ist die
unterschiedliche Anzahl Felder pro Datensatz, während eine Spalte in
jedem Datensatz vorkommt.
Ein contactAppsRecord kann muss aber nicht Felder enthalten. Ein

Beispiel mit Feldern:
contactAppsTable = contactAppsAccounts
Mit Feldnamen:
contactAppsRecord = contactAppsFieldName1 + '\t' +
contactAppsFieldName1 + ': ' + contactAppsFieldValue1 + '<§>' +
contactAppsFieldName2 + ': ' + contactAppsFieldValue2 +…+ '\n'

Mit Feldnummer:
contactAppsRecord = contactAppsFieldName1 + '\t' +
contactAppsFieldNo1 + ': ' + contactAppsFieldValue1 + '<§>' +
contactAppsFieldNo2 + ': ' + contactAppsFieldValue2 +…+ '\n'
Mit Feldnamen (2 Datensätze):

1) Mustermann GmbH Name: Mustermann GmbH<§>Typ:
Kunde<§>Mitarbeiterzahl: 10<§>Jahresumsatz: 5.000.000<§>Branche:
Dienstleistung<§>Telefon: +49 176 236498<§>Quelle: Externe
Empfehlung
2) Mustermann GmbH Name: Mustermann GmbH<§> Jahresumsatz:
10.000.000
Mit Feldnummer (2 Datensätze):

1) Mustermann GmbH 1: Mustermann GmbH<§>2: Kunde<§>3:
10<§>4: 5.000.000<§>5: Dienstleistung<§>6: +49 176 236498<§>7:
Externe Empfehlung
2) Mustermann GmbH 1: Mustermann GmbH<§>4: 10.000.000
In Textdateien (contactAppsTable) werden einzelne Zeilen

(contactAppsRecord) nur (hintendran) hinzugefügt bzw. sequenziell (von
der ersten bis zur letzten Zeile) gelesen. Dadurch haben alle Felder nach
dem Lesen immer den letzten (aktuellen) Inhalt ganz Gleich wer nun im
Team den letzten Eintrag vorgenommen hat.
Praktische Anwendung: contactApps (www.contactApps.de)

Kundenverwaltung (Kontakte, Accounts, Leads, Opportunities).
contactAppsRecord ohne Felder. Der Datensatz besteht aus Kurztext +

Tab + Text. Dieser Ansatz ist sehr gut für Kommunikationsaufgaben, wie
Chat oder Blog geeignet. Man chattet oder postet Text, der dann im Chat-
oder Blog-Fenster gezeigt wird.
Praktische Anwendung: contactApps OpenChat und OpenBlog. Damit

ist auch eine komplette Vorgangsverfolgung möglich.
Deep Learning Modelle: Kundenstimmung schätzen (German

Sentiment) und Fragen automatisch beantworten (FAQ-Chatbot).
contactApps Datenverwaltung benötigt keine aufwendige Indexierung und

Verknüpfungen. Alle Textdateien (contactAppsTable) werden auf einem
Linux-Server oder in der Cloud verwaltet. Die Kommunikation vom Client
bis zum Webserver (SSL-Proxy) erfolgt als REST über TLS (HTTPS) und
dann weiter zum RESTful-Server z.B. Flask (Python 3). Es werden keine
weiteren Ressourcen (z.B. relationale Datenbank) gebraucht. Aufgrund der
flachen Architektur (Textdateien) und der Skalierbarkeit von Webserver
und RESTful-Server werden konkurrierende Zugriffe problemlos

gehändelt. Die Antwortzeiten auch bei zehntausenden Datensätzen liegen
je nach Serverleistung im Bereich um 1 s.
10. Digital Transformation
Die digitale Transformation ist ein Phänomen, mit dem sich jedes
Unternehmen auseinandersetzen muss. Kunden verlangen neue
Erfahrungen, Partner erwarten einen besseren Zugang, Mitarbeiter wollen
mehr Komfort und die Möglichkeit von überall auf Systeme und Daten
zugreifen zu können. Unternehmen, die lernen, in einer integrierten,
vernetzten Weise zu arbeiten, haben große Vorteile. Der Wandel zu einer
zukunftssicheren, serviceorientierten Architektur, von der Infrastruktur bis
zu der Software führt zwangsläufig über die Cloud.
Infrastructur-as-a-Service
Infrastructure-as-a-Service (IaaS) erfordert die externe Verlegung der
physischen Infrastruktur von IT-Systemen, wie Speicher, Hardware,
Server und Netzwerkkomponenten für Zugriffe as-a-Service über das
Internet. Die Reduzierung der IT-Kosten durch die Migration auf virtuelle
Server und die Steigerung der Geschäftsflexibilität durch den Einsatz von
On-Demand Ressourcen sind die häufigsten Gründe für die Einführung von
IaaS.
Platform-as-a-Service
Platform-as-a-Service (PaaS) ist die nächste Schicht im Cloud Computing
Modell. PaaS ist die Softwaregrundlage für Cloudanwendungen, wie
Entwicklungswerkzeuge, Frameworks, Datenbanken und Tools. Amazon
AWS, Microsoft Azure, IBM Cloud, Google Cloud Platform, SAP Cloud
Platform und Saleforce Cloud Platform sind führende Anbieter von PaaS.
Für deutsche Unternehmen wird Datenschutz (Datenhaltung in
Deutschland oder wenigstens in der EU) immer wichtiger. Auch Multi-
Cloud-Lösungen werden zunehmend präferiert.
Software-as-a-Service
Software-as-a-Service (SaaS) ist das Nutzungsmodell für
Softwareanwendungen als Dienstleitung über das Internet. Alle Salesforce
Produkte sind beispielsweise komplett SaaS.
Software On-Premises
Software On-Premises ist das Backoffice-Modell für Softwareanwendungen
beim Kunden vor Ort. Enterprise-Systeme, wie SAP und Oracle ERP
gehören ebenfalls dazu.

Expert-as-a-Service
Erfahrene Spezialisten (Experten) beraten, entwickeln, implementieren,
administrieren, konfigurieren, optimieren, schulen und supporten live-
online. Die großen Vorteile liegen auf der Hand: Dank Bildschirm-
übertragung (Screen Sharing) und Videokonferenz verlaufen solche
Dienstleistungen mit hoher Effektivität und kostensparend as-a-Service
über das Internet.
Experten as-a-Service (EaaS) sind global verfügbar und können auch
kurzfristig stunden- bzw. tageweise gebucht und abgerechnet werden. Der
interaktive Live-Kontakt ersetzt dabei den persönlichen Kontakt.
Wie es funktioniert
Agenda und Roadmap

Erfolgreiche digitale Transformation basiert auf einer gründlichen Planung.
Am Anfang ist wichtig, eine Roadmap für die digitale Umwandlung zu
erarbeiten, um sicherzustellen, dass abgesteckte Unternehmensziele
(Agenda) erreicht werden. Genauso wichtig ist aber auch, diese Planung
laufend zu überprüfen und die Zielrichtung regelmäßig anzupassen.
Projektmanagement oder -coaching

Die Definition der für die Umsetzung erforderlichen Projekte und die
Auswahl der dazu passenden Vorgehensweise (klassisch oder agil), unter
Berücksichtigung der vorhandenen Ressourcen sind die Grundlage für eine
schnelle und erfolgreiche Transformation. Den Einfluss neuer Technologien
auf laufende Projekte muss periodisch bewertet, aktuelle Trends
berücksichtigt und notwendige Anpassungen vorgenommen werden.
Transformation und Integration

Als Integration bezeichnen wir die Verbindung von Cloudanwendungen
(SaaS) untereinander und mit verschiedensten unternehmensinternen
(On-Premises) Applikationen und Daten zu einer zukunftssicheren
serviceorientierten Architektur. Im Prozess der Digitalisierung stellen
stetige technologische Veränderungen zahlreiche Unternehmen vor große
Herausforderungen, denn die Geschwindigkeit, mit der die IT auf die
neuen Anforderungen reagieren soll, oft sowohl die eingesetzte Software
als auch die Organisation an ihre Grenzen führt. Mit einer geeigneten
Integrationsplattform (iPaaS) ist eine umfassende Lösung möglich, mit der
das Unternehmen während und auch nach der Transformation mitwächst.
Transformation und Künstliche Intelligenz

Künstliche Intelligenz wird sich in vielen Bereichen durchsetzen, weil sie
einen entscheidenden technologischen Vorteil aufweist: Sie vereinfacht
Prognosen. Diese prognostische Kompetenz erleichtert die Entwicklung
komplexer Systeme und beschleunigt damit die digitale Transformation.

References
Iz Beltagy, Kyle Lo, and Arman Cohan. 2019. Scibert: Pretrained language
model for scientific text. In Proceedings of EMNLP.
Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2018.
BERT: Pre-training of deep bidirectional transformers for language under-
standing.arXiv preprint arXiv:1810.04805, pages 1–16.
Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019.
Bert: Pre-training of deep bidirectional transformers for language
understanding. In Proceedings of NAACL, pages 4171–4186.
Kexin Huang, Jaan Altosaar, and Rajesh Ranganath. 2019. Clinicalbert:

Modeling clinical notes and predicting hospital readmission.
arXiv:1904.05342.
Ikuya Yamada, Hiroyuki Shindo, Hideaki Takeda, and Yoshiyasu Takefuji

2016. Joint learning of the embedding of words and entities for named
entity dis-ambiguation. InCoNLL, Berlin, Germany.
Ikuya Yamada, Akari Asai, Jin Sakuma, Hiroyuki Shindo, Hideaki Takeda,
Yoshiyasu Takefuji, Yuji Matsumoto 2020. Wikipedia2Vec: An Efficient
Toolkit for Learning and Visualizingthe Embeddings of Words and Entities
from Wikipedia.
Yi Yang, Mark Christopher Siy UY and Allen Huang. 2020. FinBERT: A

Pretrained Language Model for Financial Communications.
arXiv:2006.08097v2.
Dimiter Nasev 2020. Google BERT – deutschsprachige Anwendungen

entwickeln und bereitstellen. Wikipedia2Vec German Applications.
Nina Poerner, Ulli Waltinger, and Hinrich Schuetze 2019. BERT is Not a
Knowledge Base (Yet): Factual Knowledge vs. Name-Based Reasoning in
Unsupervised QA.arXiv preprint arXiv:1911.03681v1.
Julian Risch, Anke Stoll, Marc Ziegele and Ralf Krestel. 2019. hpiDEDIS at
GermEval 2019: Offensive Language Identification using a German BERT
model.
Dietmar Schabus, Marcin Skowron and Martin Trapp, 2017. One Million
Posts: A Data Set of German Online Discussions. Proceedings of the 40th
International ACM SIGIR Conference on Research and Development in
Information Retrieval (SIGIR). Pages 1241-1244. Tokyo, Japan. Doi:
10.1145/3077136.3080711.

German Bert Applications

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

German Bert Applications

Hochgeladen von

Copyright:

Verfügbare Formate

German BERT Applications

Google BERT – deutschsprachige

Priv.-Doz. Dr. Dimiter Nasev

1. German BERT Model Selection....................................................................................................... 3

6. Pre-training with BERT ......................................................................................................... 45

8. Multilingual BERT Applications ........................................................................................... 50

9. contactApps Datenverwaltung in Textdateien.............................................................. 51

10. Digital Transformation ........................................................................................................... 53

German BERT Applications -2-

Ende 2018 haben Google-Entwickler eine neue Technik für die

Für deutschsprachige Anwendungen braucht man ein deutschsprachiges

Für unsere vergleichenden Untersuchungen haben wir GermEval-Daten

Bei unseren Untersuchungen schneidet Deepset BERT marginal besser (ca.

German BERT Applications -3-

BERT basiert auf einem Transformer-Modell. Ein Transformer besteht aus

Beispiel: Text A = “my dog is cute”; Text B = “he likes playing”

Tokeneinbettungen: Ein [CLS] -Token wird am Anfang und ein [SEP] -

German BERT Applications -4-

Positionseinbettungen: Jedem Token wird eine Positionseinbettung

Zwei Faktoren sind maßgeblich für die Überlegenheit der BERT-Modelle

1. Das BERT-Modell (Anwendung) entsteht in zwei Schritte. Zuerst

2. Das BERT-Modell wird so trainiert, dass eine optimale Vorhersage

Im Weiteren setzen wir ausschließlich auf TensorFlow BERT und Serving:

German BERT Applications -5-

Für unsere vergleichenden Untersuchungen haben wir GermEval-Daten

Das Projekt sucht u.a. nach Möglichkeiten, beleidigende deutschsprachige

German BERT Applications -6-

German BERT Applications -7-

Beim Feintunen wurden zwei Parameter variiert: max_seq_length und

Google Multilingual BERT Deepset BERT

eval_accuracy = 0.7703728 eval_accuracy = 0.7875289

eval_accuracy = 0.76542395 eval_accuracy = 0.7792808

eval_accuracy = 0.76542395 eval_accuracy = 0.7773012

German BERT Applications -8-

BERT-Modelle werden in der Regel mit Flask und/oder TensorFlow Serving

Die Funktion serving_input_fn definiert den gewünschten Input beim

Die Deepset-BERT Exportdatei ist um ca. 270 MB und die vcab-Datei um

Inwieweit sich diese Größenunterschiede auf die Performance nach

Für Prognosezwecke können bereits exportierte Modelle wieder geladen

German BERT Applications -9-

Der folgende Code ist eine fast komplette Implementierung der

Der Ablauf einer BERT-Webanwendung sieht in etwa wie folgt aus:

1. Javascript POST-Request von der Webanwendung an den Webserver:

German BERT Applications -10-

3. Flask predict_fn oder POST-Request zum Modell-Server (TensorFlow

German BERT Applications -11-

German BERT Applications -12-

Für unsere Untersuchungen haben wir das "German News Articles

Die Prognosegenauigkeit beim Thematisieren von deutschsprachigen

Das feinjustierte Deepset BERT-Modell wurde ins Internet bereitgestellt.

Mit Google BERT - Bidirectional Encoder Representations from

Mit Google BERT versuchen wir deutschsprachige Nachrichten aufgrund

Für deutschsprachige Anwendungen braucht man ein deutschsprachiges

German BERT Applications -13-

mit TensorFlow Serving:

Für unsere Untersuchungen haben wir "German News Articles Dataset"

Das Projekt sucht u.a. nach Möglichkeiten, Nachrichten automatisch zu

Das Trainingsdatenset (train.tsv) betrug gut 10.273 Nachrichten. Das

German BERT Applications -14-

Deepset BERT Google Multilingual BERT

eval_accuracy = 0.90564203 eval_accuracy = 0.8920233

Die Prognosegenauigkeit beim Thematisieren von deutschsprachigen

Das so feinjustierte BERT-Modell wurde exportiert und ins Internet