Klassifizierung von Text mit einem angepassten Klassifizierungsmodell

Format der Eingabedaten für das Trainieren

Klassifikationsblöcke akzeptieren Trainingsdaten im CSV- und im JSON-Format.

• CSV-Format

  Die CSV-Datei sollte keinen Header enthalten. Jede Zeile in der CSV-Datei stellt einen Beispieldatensatz dar. Jeder Datensatz verfügt über mindestens eine Spalte. Die erste Spalte stellt den Text dar und die nachfolgenden Spalten die dem Text zugeordneten Bezeichnungen.

  Hinweis:

  • Die SVM- und CNN-Algorithmen unterstützen keine Trainingsdaten, wenn die Instanz nicht über Bezeichnungen verfügt. Wenn Sie den SVM-Algorithmus, den CNN-Algorithmus oder ein Ensemble mit einem dieser Algorithmen verwenden, muss jede CSV-Zeile mindestens eine Beschriftung (d. h. zwei Spalten) enthalten.
  • Der BERT-Algorithmus unterstützt Trainingsdaten mit 0, 1 oder mehr Bezeichnungen für jede Instanz.

  Example 1,label 1
  Example 2,label 1,label 2
  

• JSON-Format

  Die Trainingsdaten werden durch ein Array mit mehreren JSON-Objekten dargestellt. Jedes JSON-Objekt stellt eine Trainingsinstanz dar und muss über ein Text- und ein Beschriftungsfeld verfügen. Das Textfeld stellt das Trainingsbeispiel dar und das Bezeichnungsfeld speichert die zugeordneten Bezeichnungen für das Beispiel (0, 1 oder mehr Bezeichnungen).

  [
      {
      "text": "Example 1",
      "labels": ["label 1"]
      },
      {
      "text": "Example 2",
      "labels": ["label 1", "label 2"]
      },
      {
      "text": "Example 3",
      "labels": []
      }
  ]
  

  Hinweis:

  • "labels": [] gibt ein Beispiel ohne Bezeichnungen an. Die SVM- und CNN-Algorithmen unterstützen keine Trainingsdaten, wenn die Instanz nicht über Bezeichnungen verfügt. Wenn Sie den SVM-Algorithmus oder den CNN-Algorithmus oder ein Ensemble mit einem dieser Algorithmen verwenden, muss jedes JSON-Objekt über mindestens eine Bezeichnung verfügen.
  • Der BERT-Algorithmus unterstützt Trainingsdaten mit 0, 1 oder mehr Bezeichnungen für jede Instanz.

Voraussetzungen für Eingabedaten

Für SVM- und CNN-Algorithmen:

• Erforderliche Mindestanzahl eindeutiger Bezeichnungen: 2
• Erforderliche Mindestanzahl der Textbeispiele pro Bezeichnung: 5

Für BERT-Algorithmus:

• Erforderliche Mindestanzahl eindeutiger Bezeichnungen: 1
• Erforderliche Mindestanzahl der Textbeispiele pro Bezeichnung: 5

Beachten Sie, dass die Trainingsdaten im CSV- oder JSON-Format vor dem Trainieren in einen Datenstrom umgewandelt werden. Anstelle von Trainingsdatendateien können Sie auch Datenströme direkt an die Trainingsfunktionen der Klassifikationsblöcke übergeben.

Stoppwörter

Sie können eigene Stoppwörter angeben, die bei der Vorverarbeitung entfernt werden. Eingaben für Stoppwortdateien werden in einem Standardformat erwartet: eine einzelne Textdatei mit einem Ausdruck pro Zeile. Stoppwörter können als Liste oder als Datei in einem Standardformat bereitgestellt werden.

Stoppwörter können nur mit dem Ensemble-Klassifikationsmerkmal verwendet werden.

SVM-Algorithmen trainieren

SVM (Support Vector Machine) ist ein Klassifikationsmerkmal, das mithilfe von Vorhersagen für jede Art von Eingabe trainiert werden kann, die von den Einbettungs- oder Vektorisierungsblöcken als Merkmalsvektoren bereitgestellt werden (z. B. durch USE-Einbettungen (USE = Universal Sentence Encoder) und TF-IDF-Vektorisierungsroutinen. Es unterstützt die Textklassifizierung mit mehreren Klassen und mehreren Bezeichnungen und erzeugt Konfidenzscores mithilfe der Platt-Skalierung.

Geben Sie für alle Optionen, die zum Konfigurieren des SVM-Trainings verfügbar sind, Folgendes ein:

help(watson_nlp.blocks.classification.svm.SVM.train)

So trainieren Sie SVM-Algorithmen:

1. Beginnen Sie mit den folgenden Vorverarbeitungsschritten:

   import watson_nlp
   from watson_core.data_model.streams.resolver import DataStreamResolver
   from watson_nlp.blocks.classification.svm import SVM
   
   training_data_file = "<ADD TRAINING DATA FILE PATH>"
   
   # Create datastream from training data
   data_stream_resolver = DataStreamResolver(target_stream_type=list, expected_keys={'text': str, 'labels': list})
   training_data = data_stream_resolver.as_data_stream(training_data_file)
   
   # Load a Syntax model
   syntax_model = watson_nlp.load('syntax_izumo_en_stock')
   
   # Create Syntax stream
   text_stream, labels_stream = training_data[0], training_data[1]
   syntax_stream = syntax_model.stream(text_stream)
   

2. Trainieren Sie das Klassifizierungsmodell mithilfe von USE-Einbettungen. Eine Liste der verfügbaren, vorab trainierten Blöcke finden Sie unter Sofort einsatzfähige, vorab trainierte USE-Einbettungen.

   # download embedding
   use_embedding_model = watson_nlp.load('embedding_use_en_stock')
   
   use_train_stream = use_embedding_model.stream(syntax_stream, doc_embed_style='raw_text')
   # NOTE: doc_embed_style can be changed to `avg_sent` as well. For more information check the documentation for Embeddings
   # Or the USE run function API docs
   use_svm_train_stream = watson_nlp.data_model.DataStream.zip(use_train_stream, labels_stream)
   
   # Train SVM using Universal Sentence Encoder (USE) training stream
   classification_model = SVM.train(use_svm_train_stream)
   

CNN-Algorithmus trainieren

CNN ist eine einfache Überlagerungsnetzarchitektur, die für die Klassifizierung kurzer Texte mit mehreren Klassen und mehreren Bezeichnungen entwickelt wurde. Dabei werden GloVe-Einbettungen verwendet. GloVe-Einbettungen codieren die Semantik auf Wortebene in einen Vektorraum. Die GloVe-Einbettungen für jede Sprache werden mit dem Wikipedia-Korpus der jeweiligen Sprache trainiert. Informationen zur Verwendung von GloVe-Einbettungen finden Sie in der Open-Source-Dokumentation für GloVe-Einbettungen.

Geben Sie für alle Optionen, die zum Konfigurieren des CNN-Trainings verfügbar sind, Folgendes ein:

help(watson_nlp.blocks.classification.cnn.CNN.train)

So trainieren Sie CNN-Algorithmen:

import watson_nlp
from watson_core.data_model.streams.resolver import DataStreamResolver
from watson_nlp.blocks.classification.cnn import CNN

training_data_file = "<ADD TRAINING DATA FILE PATH>"

# Create datastream from training data
data_stream_resolver = DataStreamResolver(target_stream_type=list, expected_keys={'text': str, 'labels': list})
training_data = data_stream_resolver.as_data_stream(training_data_file)

# Load a Syntax model
syntax_model = watson_nlp.load('syntax_izumo_en_stock')

# Create Syntax stream
text_stream, labels_stream = training_data[0], training_data[1]
syntax_stream = syntax_model.stream(text_stream)

# Download GloVe embeddings
glove_embedding_model = watson_nlp.load('embedding_glove_en_stock')

# Train CNN
classification_model = CNN.train(watson_nlp.data_model.DataStream.zip(syntax_stream, labels_stream), embedding=glove_embedding_model.embedding)

Training des mehrsprachigen BERT-Algorithmus

BERT ist eine transformatorbasierte Architektur, die für die Klassifizierung von Text mit mehreren Klassen und mehreren Bezeichnungen in kurzen Texten entwickelt wurde. Es verwendet vortrainierte Modelle mit mehrsprachiger BERT.

Geben Sie für alle Optionen, die für die Konfiguration der BERT-Schulung verfügbar sind, Folgendes ein:

help(watson_nlp.blocks.classification.bert.BERT.train)

So trainieren Sie BERT-Algorithmen:

import watson_nlp
from watson_nlp.blocks.classification.bert import BERT
from watson_core.data_model.streams.resolver import DataStreamResolver
training_data_file = "<ADD TRAINING DATA FILE PATH>"

# create datastream from training data
data_stream_resolver = DataStreamResolver(target_stream_type=list, expected_keys={'text': str, 'labels': list})
train_stream = data_stream_resolver.as_data_stream(training_data_file)

# Load pre-trained BERT model
pretrained_model_resource = watson_nlp.load('pretrained-model_bert_multi_bert_multi_uncased')

# Train model
classification_model = BERT.train(train_stream, pretrained_model_resource)

Ausbildung eines Ensemblemodells

Das Ensemble-Modell ist ein gewichtetes Ensemble dieser drei Algorithmen: CNN, SVM mit TF-IDF und SVM mit USE. Sie berechnet den gewichteten Mittelwert eines Sets von Klassifikationsvorhersagen mithilfe von Konfidenzscores. Das Ensemblemodell ist sehr einfach zu bedienen.

help(watson_nlp.workflows.classification.Ensemble.train)

import watson_nlp
from watson_nlp.workflows.classification import Ensemble

training_data_file = "<ADD TRAINING DATA FILE PATH>"

# Load predefined stopwords
stopwords = watson_nlp.load('text_stopwords_classification_ensemble_en_stock')

# Note: If stopwords are available as a single text file with one phrase per line, they can instead be read in using:
# with open('my_stopwords_en.txt') as f:
#    stopwords = f.readlines()

# Train the classifier
# Set the `use_ewl` flag to True to learn the weights automatically.
ensemble_classifier_model = Ensemble.train(training_data_file, 'syntax_izumo_en_stock', 'embedding_glove_en_stock', 'embedding_use_en_stock', stopwords=stopwords, use_ewl=True)

help(watson_nlp.workflows.classification.GenericEnsemble)

import watson_nlp
from watson_nlp.workflows.classification import GenericEnsemble
from watson_nlp.workflows.classification.base_classifier import GloveCNN
from watson_nlp.workflows.classification.base_classifier import TFidfSvm
from watson_nlp.workflows.classification.base_classifier import UseSvm

training_data_file = "<ADD TRAINING DATA FILE PATH>"

# Create datastream from training data
data_stream_resolver = DataStreamResolver(target_stream_type=list, expected_keys={'text': str, 'labels': list})
training_data = data_stream_resolver.as_data_stream(training_data_file)

# Syntax Model
syntax_model = watson_nlp.load('syntax_izumo_en_stock')
# USE Embedding Model
use_model = watson_nlp.load('embedding_use_en_stock')
# GloVE Embedding model
glove_model = watson_nlp.load('embedding_glove_en_stock')

ensemble_model = GenericEnsemble.train(training_data, syntax_model,
                                           base_classifiers_params=[
                                       TFidfSvm.TrainParams(syntax_model=syntax_model),
                                               GloveCNN.TrainParams(syntax_model=syntax_model, glove_embedding_model=glove_model, cnn_epochs=5),
                                               UseSvm.TrainParams(syntax_model=syntax_model, use_embedding_model=use_model, doc_embed_style='raw_text')],
                                           use_ewl=True)

Bewährte Verfahren für das Trainieren

Für die Qualität und Menge der Daten gelten bestimmte Einschränkungen, um sicherzustellen, dass das Trainieren von Klassifizierungsmodellen in einem angemessenen Zeitraum abgeschlossen werden kann und verschiedene Leistungskriterien erfüllt. Diese Einschränkungen sind nachfolgend aufgelistet. Beachten Sie, dass es sich nicht um feste Einschränkungen handelt. Dabei gilt Folgendes: Je größer die Abweichung von diesen Richtlinien, umso größer das Risiko, dass das Modell nicht trainiert werden kann oder nicht die Anforderungen erfüllt.

• Datenmenge

  • Die größte Anzahl von Klassen, mit der ein Klassifizierungsmodell getestet wurde, ist ~1200.
  • Die am besten geeignete Textgröße für Trainings- und Testdaten für die Klassifizierung sind etwa 3000 Codepunkte. Größere Texte können zwar verarbeitet werden, jedoch möglicherweise mit geringerer Laufzeitleistung.
  • Die Trainingszeit nimmt mit der Anzahl der Beispiele und der Anzahl der Bezeichnungen zu.
  • Die Inferenzzeit nimmt mit der Anzahl der Bezeichnungen zu.

• Datenqualität

  • Die Größe jeder Stichprobe (z. B. die Anzahl der Ausdrücke in jeder Trainingsstichprobe) kann sich auf die Qualität auswirken.
  • Die Trennung der Klassen ist von Bedeutung. Mit anderen Worten: Klassen in den Trainingsdaten (und Testdaten) sollten semantisch voneinander zu unterscheiden sein, um Fehlklassifizierungen zu vermeiden. Da die Algorithmen für Algorithmen für Klassifikationsmerkmale in Watson Natural Language Processing auf Worteinbettungen basieren, können Trainingsklassen, die Textbeispiele mit zu vielen semantischen Überschneidungen enthalten, eine Klassifizierung mit hoher Qualität rechnerseitig unmöglich machen. Selbst wenn komplexere heuristische Konzepte zum Beurteilen der semantischen Ähnlichkeit zwischen Klassen vorhanden sind, sollten Sie mit einer einfachen "Sichtprüfung" für einige Beispielen aus jeder Klasse beginnen, um einzuschätzen, ob sie klar genug getrennt sind oder nicht.
  • Es wird empfohlen, zum Trainieren ausgewogene Daten zu verwenden. Im Idealfall sollten die Trainingsdaten etwa die gleiche Anzahl von Beispielen aus jeder Klasse enthalten. Andernfalls könnten die Klassifikationsmerkmale tendenziell Klassen mit einem größeren Anteil in den Trainingsdaten bevorzugen.
  • Szenarios, in denen manche Klassen in den Trainingsdaten im Vergleich zu anderen Klassen stark unterrepräsentiert sind, sollten möglichst vermieden werden.

Einschränkungen und Vorbehalte:

• Der BERT-Klassifikationsblock hat eine vordefinierte Sequenzlänge von 128 Codepunkten. Dies kann jedoch im Trainingsprozess durch Ändern des Parameters max_seq_length konfiguriert werden. Der zulässige Höchstwert für diesen Parameter ist 512. Dies bedeutet, dass der BERT-Klassifikationsblock nur zum Klassifizieren kurzer Textelemente verwendet werden kann. Text, der länger als max_seq_length ist, wird beim Klassifizierungstraining und bei der Inferenz abgeschnitten und verworfen.
• Der CNN-Klassifikationsblock hat eine vordefinierte Sequenzlänge von 1000 Codepunkten. Dieser Grenzwert kann im Trainingsprozess konfiguriert werden, indem der Parameter max_phrase_len geändert wird. Für diesen Parameter ist kein Höchstwert vorgegeben, doch das Erhöhen der maximalen Phrasenlänge führt zu erhöhter CPU- und Speicherauslastung.
• Die Sequenzlänge für SVM-Blöcke nicht begrenzt, d. h. sie können für längere Texte verwendet werden.

Modell auf neue Daten anwenden

Nachdem Sie das Modell mit einem Dataset trainiert haben, wenden Sie das Modell mit der Methode run() auf neue Daten an, wie bei den vorhandenen, vorab trainierten Blöcken.

Mustercode

• Für die Ensemble- und BERT-Modelle (z. B. für Ensemble):

  # run Ensemble model on new text
  ensemble_prediction = ensemble_classification_model.run("new input text")
  

• Für SVM- und CNN-Modelle (z. B. für CNN):

  # run Syntax model first
  syntax_result = syntax_model.run("new input text")
  # run CNN model on top of syntax result
  cnn_prediction = cnn_classification_model.run(syntax_result)
  

Geeigneten Algorithmus für Ihren Anwendungsfall auswählen

Wählen Sie dem Modellalgorithmus aus, der für Ihren Anwendungsfall am besten geeignet ist.

Beim Auswählen zwischen SVM, CNN und BERT ist Folgendes zu beachten:

• BERT

  • Sollte ausgewählt werden, wenn hohe Qualität erforderlich ist und mehr Rechenressourcen zur Verfügung stehen

• CNN

  • Sollte ausgewählt werden, wenn Daten mit angemessener Größe zur Verfügung stehen
  • Sollte ausgewählt werden, wenn GloVe-Einbettung für die erforderliche Sprache verfügbar ist
  • Sollte ausgewählt werden, wenn entweder einzelne Bezeichnungen oder mehrere Bezeichnungen verwendet werden können
  • CNN optimiert die Einbettungen. Dies kann zu einer Leistungssteigerung bei unbekannten Begriffen oder neuen Domänen führen.

• SVM

  • Sollte ausgewählt werden, wenn ein überschaubares und einfaches Modell erforderlich ist
  • SVM bietet die kürzeste Trainings- und Inferenzzeit
  • Sollte bei kleinen Datasets ausgewählt werden

Wenn Sie SVM auswählen, ist Folgendes zu berücksichtigen, um eine der verschiedenen Implementierungen von SVM auszuwälen:

• SVMs trainieren Klassifikationsmerkmale mit mehreren Bezeichnungen.
• Je größer die Anzahl der Klassen, umso länger die Trainingszeit.
• TF-IDF
  • Wählen Sie die TF-IDF-Vektorisierung mit SVM aus, wenn das Dataset klein ist (d. h. es enthält wenige Klassen, wenige Beispiele und kurze Texte; z. B. Sätze mit wenigen Phrasen).
  • TF-IDF mit SVM kann schneller sein als andere Algorithmen im Klassifikationsblock.
  • Wählen Sie TF-IDF aus, wenn für die erforderliche Sprache keine Einbettungen verfügbar sind.
• Verwenden:
  • Wählen Sie USE (Universal Sentence Encoder) mit SVM aus, wenn das Dataset einen oder mehrere Sätze im Eingabetext enthält.
  • USE kann für Datasets, bei denen das Verständnis des Kontexts von Wörtern oder Sätzen von Bedeutung ist, bessere Ergebnisse erzielen.

Das Ensemblemodell kombiniert mehrere einzelne (diverse) Modelle, um bessere Vorhersagen zu erstellen. Ziehen Sie für diesen Modelltyp die folgenden wichtigen Aspekte in Betracht:

• Das Ensemblemodell kombiniert CNN, SVM mit TF-IDF und SVM mit USE.
• Dieses Modell ist besonders leicht anzuwenden.
• Es kann eine bessere Leistung erzielen als die einzelnen Algorithmen.
• Es kann auf alle Arten von Datasets angewendet werden. Das Trainieren großer Datasets (mit über 20000 Beispielen) kann jedoch lange dauern.
• In einem Ensemblemodell können Sie Gewichtungen festlegen. Diese Gewichtungen entscheiden darüber, wie das Ensemblemodell die Ergebnisse einzelner Klassifikationsmerkmale kombiniert. Derzeit erfolgt die Auswahl der Gewichtungen heuristisch und muss durch Versuch und Irrtum festgelegt werden. Die in der Funktion bereitgestellten Standardgewichtungen sind ein guter Ausgangspunkt zum Experimentieren.

Übergeordnetes Thema: Eigene Modelle erstellen