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 über 0, 1 oder mehr Beschriftungen verfügt.

  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 über 0, 1 oder mehr Beschriftungen verfügt.

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-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 Bezeichnungen und erstellt Vertrauenswerte durch die Verwendung 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_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 GloVe Einbettungen, siehe 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_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)

Transformer-Algorithmus mithilfe des Slate-Modells von IBM trainieren

Der Transformer-Algorithmus mit einem vorab trainierten Slate IBM Das Foundation-Modell kann für die Textklassifizierung mit mehreren Klassen und mehreren Labels für kurze Texte verwendet werden.

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

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

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

So trainieren Sie 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 den folgenden Code ein, um eine Liste aller Optionen abzurufen, die für die Konfiguration eines Transformatortrainings verfügbar sind:

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

Informationen zum Trainieren von Umsetzungsalgorithmen finden Sie im folgenden 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)

Ensemblemodell trainieren

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.

Das Klassifikationsmerkmal GenericEnsemble bietet dem Benutzer mehr Flexibilität bei der Auswahl der drei Basisklassifikationsmerkmale TFIDF-SVM, USE-SVM und CNN. Für Texte von 50 bis 1000 Zeichen ergibt die Kombination aus TFIDF-SVM und USE-SVM Klassifikatoren oft eine gute Balance zwischen Qualität und Leistung. Bei einigen mittleren oder langen Dokumenten (500-1000 + Zeichen) kann das Hinzufügen des CNN zum Ensemble helfen, die Qualität zu erhöhen, aber es kommt in der Regel mit einem erheblichen Einfluss auf die Laufzeitleistung (geringerer Durchsatz und erhöhte Modellladezeit).

Geben Sie für alle Optionen, die für die Konfiguration des Ensembletrainings verfügbar sind, Folgendes 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 Ensemblemodelle:

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

Beachten Sie bei der Auswahl zwischen SVM, CNN und Transformern Folgendes:

• Transformatorbasierte Verzögerung

  • 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