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.
  • Die BERT-basierten und Slate-basierten Transformer-Algorithmen unterstützen Trainingsdaten, bei denen jede Instanz 0, 1 oder mehr als ein Label hat.

  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.
  • Die BERT-basierten und Slate-basierten Transformer-Algorithmen unterstützen Trainingsdaten, bei denen jede Instanz 0, 1 oder mehr als ein Label hat.

Voraussetzungen für Eingabedaten

Für SVM- und CNN-Algorithmen:

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

Für die BERT-basierten und Slate-basierten Transformer-Algorithmen:

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

Trainingsdaten im CSV- oder JSON-Format werden vor dem Training in einen DataStream konvertiert. 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 Klassifizierung von Texten mit mehreren Klassen und Labels und erzeugt Konfidenzwerte mit Hilfe von Platt Scaling.

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_nlp.toolkit.classification_utils.train_util import prepare_data_from_json
   from watson_nlp.blocks.classification.svm import SVM
   
   training_data_file = "train_data.json"
   
   # Load a Syntax model
   syntax_model = watson_nlp.load('syntax_izumo_en_stock')
   
   # Create datastream from training data
   train_stream = prepare_data_from_json(training_data_file, syntax_model)
   syntax_stream, labels_stream = train_stream[0], train_stream[1]
   

2. Trainieren Sie das Klassifizierungsmodell mithilfe von USE-Einbettungen. Siehe ' Vortrainierte USE-Einbettungen, die in für eine Liste der verfügbaren, vortrainierten Blöcke.

   # 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 finden Sie unter GloVe.

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)

Zum Trainieren von CNN-Algorithmen:

import watson_nlp
from watson_nlp.toolkit.classification_utils.train_util import prepare_data_from_json
from watson_nlp.blocks.classification.cnn import CNN

training_data_file = "train_data.json"

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

# Create datastream from training data
train_stream = prepare_data_from_json(training_data_file, syntax_model)
syntax_stream, labels_stream = train_stream[0], train_stream[1]

# 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 Transformationsalgorithmus mit dem IBM Slate-Modell

Der Transformer-Algorithmus, der ein vortrainiertes Slate IBM Foundation-Modell verwendet, kann für die Klassifizierung von Kurztexten mit mehreren Klassen und Labels eingesetzt werden.

Für alle Optionen, die für die Konfiguration des Transformer-Trainings verfügbar sind, geben Sie ein:

help(watson_nlp.blocks.classification.transformer.Transformer.train)

Eine Liste der verfügbaren Slate-Modelle finden Sie in dieser Tabelle:

Zum Trainieren von Transformer-Algorithmen:

import watson_nlp
from watson_nlp.blocks.classification.transformer import Transformer
from watson_nlp.toolkit.classification_utils.train_util import prepare_stream_of_train_records
from watson_nlp import data_model as dm

training_data_file = "train_data.json"

# Create datastream from training data
train_data_stream = dm.DataStream.from_file(training_data_file)
train_record_data_stream = prepare_stream_of_train_records(train_data_stream)

# Load pre-trained slate model
pretrained_model_resource = watson_nlp.load('<pretrained Slate model>')

# Train model - note that Transformer uses Slatea by default
classification_model = Transformer.train(train_data_stream=train_record_data_stream,
                                         pretrained_model_resource=pretrained_model_resource)

Training eines benutzerdefinierten Transformatormodells unter Verwendung eines von Hugging Face bereitgestellten Modells

Sie können Ihr benutzerdefiniertes transformatorbasiertes Modell trainieren, indem Sie ein bereits trainiertes Modell aus Hugging Face verwenden.

Um ein "Hugging Face"-Modell zu verwenden, geben Sie den Modellnamen als " pretrained_model_resource -Parameter in der " train -Methode von " watson_nlp.blocks.classification.transformer.Transformer an. Rufen Sie https://huggingface.co/models auf, um den Modellnamen zu kopieren.

Geben Sie diesen Code ein, um eine Liste aller Optionen zu erhalten, die für die Konfiguration einer Transformatorausbildung verfügbar sind:

help(watson_nlp.blocks.classification.transformer.Transformer.train)

Informationen zum Trainieren von Transformationsalgorithmen finden Sie in diesem Codebeispiel:

import watson_nlp
from watson_nlp.blocks.classification.transformer import Transformer
from watson_nlp.toolkit.classification_utils.train_util import prepare_stream_of_train_records
from watson_nlp import data_model as dm

training_data_file = "train_data.json"

# Create datastream from training data
train_data_stream = dm.DataStream.from_file(training_data_file)
train_record_data_stream = prepare_stream_of_train_records(train_data_stream)

# Specify the name of the Hugging Face model
huggingface_model_name = 'xml-roberta-base'

# Train model
classification_model = Transformer.train(train_data_stream=train_record_data_stream,
                                         pretrained_model_resource=huggingface_model_name)

Training eines Ensemble-Modells

Das Ensemble-Modell ist ein gewichtetes Ensemble aus diesen drei Algorithmen: CNN, SVM mit TF-IDF und SVM mit USE. Es berechnet den gewichteten Mittelwert einer Reihe von Klassifizierungsvorhersagen unter Verwendung von Konfidenzwerten. Das Ensemble-Modell ist sehr einfach zu bedienen.

Der GenericEnsemble bietet dem Benutzer mehr Flexibilität bei der Auswahl zwischen den drei Basisklassifikatoren TFIDF-SVM, USE-SVM und CNN. Für Texte mit 50 bis 1000 Zeichen ergibt die Kombination von TFIDF-SVM und USE-SVM-Klassifikatoren oft ein gutes Gleichgewicht zwischen Qualität und Leistung. Bei einigen mittelgroßen oder langen Dokumenten (500-1000+ Zeichen) kann das Hinzufügen des CNN zum Ensemble die Qualität verbessern, aber es geht in der Regel mit erheblichen Auswirkungen auf die Laufzeitleistung einher (geringerer Durchsatz und längere Modellladezeit).

Für alle Optionen, die für die Konfiguration des Ensemble-Trainings verfügbar sind, geben Sie ein:

help(watson_nlp.workflows.classification.GenericEnsemble)

Zum Trainieren von Ensemble-Algorithmen:

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

training_data_file = "train_data.json"

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

# GloVE Embedding model
glove_embedding_model = watson_nlp.load('embedding_glove_en_stock')

# Train classifier using the manually defined base classifier and manually defined weights¶
classification_model = GenericEnsemble.train(training_data_file,
                                             syntax_model,
                                             base_classifiers_params=[
                                                TFidfSvm.TrainParams(syntax_model=syntax_model),
                                                GloveCNN.TrainParams(syntax_model=syntax_model,
                                                                     glove_embedding_model=glove_embedding_model,
                                                                    )],
                                             weights=[2,1])

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 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-Modelle:

  # 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.

Bei der Wahl zwischen SVM, CNN und Transformers ist Folgendes zu beachten:

• Transformator-basierter Schiefer

  • 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