Format des données d'entrée pour la formation

Les blocs de classification acceptent les données de formation au format CSV et JSON.

• Format CSV

  Le fichier CSV ne doit pas contenir d'en-tête. Chaque ligne du fichier CSV représente un exemple d'enregistrement. Chaque enregistrement comporte une ou plusieurs colonnes, où la première colonne représente le texte et les colonnes suivantes représentent les libellés associés à ce texte.

  Remarque :

  • Les algorithmes SVM et CNN ne prennent pas en charge les données de formation lorsqu'une instance n'a pas d'étiquette. Ainsi, si vous utilisez l'algorithme SVM, ou l'algorithme de CNN, ou un ensemble comprenant l'un de ces algorithmes, chaque ligne CSV doit avoir au moins une étiquette, c'est-à-dire 2 colonnes.
  • Les algorithmes BERT et Slate-based Transformer prennent en charge les données d'apprentissage où chaque instance a 0, 1 ou plus d'un libellé.

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

• Format JSON

  Les données de formation sont représentées sous la forme d'un tableau contenant plusieurs objets JSON. Chaque objet JSON représente une instance de formation et doit avoir un texte et une zone de libellés. Le texte représente l'exemple de formation, et les libellés stocke les libellés associés à l'exemple (0, 1 ou plusieurs libellés).

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

  Remarque :

  • "labels": [] indique un exemple sans libellés. Les algorithmes SVM et CNN ne prennent pas en charge les données de formation lorsqu'une instance n'a pas d'étiquette. Ainsi, si vous utilisez l'algorithme SVM, ou l'algorithme de CNN, ou un ensemble comprenant l'un de ces algorithmes, chaque objet JSON doit avoir au moins une étiquette.
  • Les algorithmes BERT et Slate-based Transformer prennent en charge les données d'apprentissage où chaque instance a 0, 1 ou plus d'un libellé.

Données d'entrée requises

Pour les algorithmes SVM et CNN :

• Nombre minimal de libellés uniques requis : 2
• Nombre minimal d'exemples de texte requis par étiquette : 5

Pour les algorithmes Transformer basés sur BERT et Slate:

• Nombre minimal de libellés uniques requis : 1
• Nombre minimal d'exemples de texte requis par étiquette : 5

Les données d'apprentissage au format CSV ou JSON sont converties en DataStream avant l'apprentissage. Au lieu de formation de fichiers de données, vous pouvez également transmettre des flux de données directement aux fonctions de formation des blocs de classification.

Mots vides

Vous pouvez fournir vos propres mots vides qui seront supprimés lors du prétraitement. Les entrées de fichier Stopwords sont attendues dans un format standard: un fichier texte unique avec une phrase par ligne. Les mots d'arrêt peuvent être fournis en tant que liste ou en tant que fichier dans un format standard.

Les mots d'arrêt ne peuvent être utilisés qu'avec le discriminant Ensemble.

Formation des algorithmes SVM

SVM est un discriminant de machine à vecteur de support qui peut être formé à l'aide de prévisions sur n'importe quel type d'entrée fourni par les blocs d'incorporation ou de vectorisation comme vecteurs de fonction, par exemple, par USE (Universal Sentence Encoder) et TF-IDF vectorizers. Il prend en charge la classification de texte multi-classes et multi-étiquettes et produit des scores de confiance à l'aide de Platt Scaling.

Pour toutes les options disponibles pour la configuration de la formation SVM, entrez :

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

Pour former des algorithmes SVM :

1. Commencez par les étapes de prétraitement suivantes :

   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. Former le modèle de classification à l'aide de l'intégration USE. Voir les USE embeddings préformés qui sont inclus dans pour une liste des blocs préformés disponibles.

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

Formation de l'algorithme de CNN

CNN est une simple architecture de réseau convolutionnaire, construite pour une classification de texte multi-classes et multi-étiquette sur des textes courts. Il utilise des intégrations GloVe. Les intégrations GloVe encodent des sémantiques de niveau mot dans un espace vectoriel. Les intégrations GloVe pour chaque langue sont formées sur le corpus Wikipédia dans cette langue. Pour plus d'informations sur l'utilisation GloVe intégrations, voir GloVe Intégrations.

Pour toutes les options disponibles pour configurer la formation CNN, entrez :

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

Pour entraîner des algorithmes CNN:

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)

Entraînement de l'algorithme du transformateur à l'aide du modèle IBM Slate

L'algorithme de transformateur utilisant une Slate pré-entraînée IBM Le modèle Foundation peut être utilisé pour la classification de textes multi-classes et multi-étiquettes sur des textes courts.

Pour toutes les options disponibles pour la configuration de la formation Transformer, entrez:

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

Pour une liste des modèles Slate disponibles, consultez ce tableau :

Pour entraîner des algorithmes Transformer:

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)

Formation d'un modèle de transformateur personnalisé en utilisant un modèle fourni par Hugging Face

Vous pouvez entraîner votre modèle personnalisé à base de transformateurs en utilisant un modèle pré-entraîné de Hugging Face

Pour utiliser un modèle de Hugging Face, spécifiez le nom du modèle en tant que paramètre " pretrained_model_resource dans la méthode " train de " watson_nlp.blocks.classification.transformer.Transformer. Allez sur https://huggingface.co/models pour copier le nom du modèle.

Pour obtenir la liste de toutes les options disponibles pour la configuration d'un entraînement de transformateur, entrez le code suivant:

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

Pour plus d'informations sur l'entraînement des algorithmes de transformation, reportez-vous à l'exemple de code suivant:

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)

Entraînement d'un modèle d'ensemble

Le modèle Ensemble est un ensemble pondéré de ces trois algorithmes: CNN, SVM avec TF-IDF et SVM avec USE. Il calcule la moyenne pondérée d'un ensemble de prévisions de classification à l'aide de scores de confiance. Le modèle d'ensemble est très facile à utiliser.

Le discriminant GenericEnsemble offre plus de souplesse à l'utilisateur pour qu'il puisse choisir parmi les trois discriminants de base TFIDF-SVM, USE-SVM et CNN. Pour les textes allant de 50 à 1000 caractères, l'utilisation de la combinaison de discriminants TFIDF-SVM et USE-SVM donne souvent un bon équilibre entre la qualité et les performances. Sur certains documents moyens ou longs (plus de 500 à 1000 caractères), l'ajout de CNN à l'Ensemble peut contribuer à augmenter la qualité, mais il est généralement fourni avec un impact significatif sur les performances d'exécution (débit plus faible et temps de chargement du modèle plus long).

Pour toutes les options disponibles pour la configuration de l'entraînement de l'Ensemble, entrez:

help(watson_nlp.workflows.classification.GenericEnsemble)

Pour former les algorithmes d'Ensemble :

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])

Formation des meilleures pratiques

Il existe certaines contraintes sur la qualité et la quantité des données pour s'assurer que la formation du modèle de classification peut se terminer dans un délai raisonnable et qu'elle répond également à divers critères de rendement. Ces données sont énumérées ci-dessous. Notez qu'il ne s'agit pas de restrictions sévères. Cependant, plus on s'écarte de ces lignes directrices, plus il est probable que le modèle ne s'entraîne pas ou que le modèle ne soit pas satisfaisant.

• Quantité de données

  • Le plus grand nombre de classes du modèle de classification a été testé sur ~1200.
  • La taille de texte la mieux adaptée pour les données de formation et de test pour la classification est d'environ 3000 points de code. Cependant, des textes plus volumineux peuvent également être traités, mais la performance d'exécution peut être plus lente.
  • Le temps de formation augmentera en fonction du nombre d'exemples et du nombre d'étiquettes.
  • Le temps d'inférence augmente en fonction du nombre d'étiquettes.

• Qualité des données

  • La taille de chaque échantillon (par exemple, le nombre de phrases dans chaque échantillon de formation) peut influer sur la qualité.
  • La séparation des classes est importante. En d'autres termes, les classes entre les données de formation (et de test) doivent être distinguées sémantiquement les unes des autres afin d'éviter les erreurs de classification. Etant donné que les algorithmes de discriminant dans Watson Natural Language Processing s'appuient sur des intégrations de mots, les classes de formation qui contiennent des exemples de texte avec un chevauchement sémantique trop important peuvent rendre la classification de haute qualité informatique intractable. Alors que des heuristiques plus sophistiquées peuvent exister pour évaluer la similarité sémantique entre les classes, vous devez commencer par un simple "test visuel" de quelques exemples de chaque classe pour discerner si elles semblent bien séparées.
  • Il est recommandé d'utiliser des données équilibrées pour la formation. Idéalement, il devrait y avoir un nombre à peu près égal d'exemples tirés de chaque classe dans les données de formation, faute de quoi les classificateurs peuvent être biaisés vers des classes plus représentées dans les données de formation.
  • Il est préférable d'éviter des situations où certaines classes de données de formation sont fortement sous-représentées par rapport à d'autres classes.

Limites et mises en garde :

• Le bloc de classification CNN a une longueur de séquence prédéfinie de 1000 points de code. Cette limite peut être configurée en temps de formation en modifiant le paramètre max_phrase_len. Il n'y a pas de limite maximale pour ce paramètre, mais l'augmentation de la longueur de phrase maximale affectera la consommation de l'unité centrale et de la mémoire.
• Les blocs SVM n'ont pas une telle limite de longueur de séquence et peuvent être utilisés avec des textes plus longs.

Application du modèle sur de nouvelles données

Une fois que vous avez entraîné le modèle sur un fichier, appliquez le modèle sur de nouvelles données à l'aide de la méthode run(), comme vous l'utilisiez sur n'importe lequel des blocs préformés existants.

Exemple de code

• Pour les modèles Ensemble:

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

• Pour les modèles SVM et CNN, par exemple pour 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)
  

Choix de l'algorithme approprié pour votre cas d'utilisation

Vous devez choisir l'algorithme de modèle qui convient le mieux à votre cas d'utilisation.

Lorsque vous choisissez entre SVM, CNN et Transformers, tenez compte des points suivants:

• Ardoise à base de transformateur

  • Choisissez quand une qualité élevée est requise et que des ressources informatiques plus élevées sont disponibles.

• CNN

  • Choisir quand des données de taille décente sont disponibles
  • Choisissez si l'intégration de GloVe est disponible pour la langue requise
  • Choisissez si vous avez l'option entre une étiquette unique et une étiquette multi-étiquette
  • CNN fine des mélodies intégraux, de sorte qu'elle pourrait donner de meilleures performances pour des termes inconnus ou des domaines plus récents.

• SVM

  • Choisissez si un modèle plus simple et plus simple est requis
  • SVM a le temps de formation et d'inférence le plus rapide
  • Choisissez si la taille de votre ensemble de données est petit

Si vous sélectionnez SVM, vous devez prendre en compte les éléments suivants lors du choix entre les différentes implémentations de SVM :

• Les SVSM forment des classificateurs multi-label.
• Plus le nombre de classes est élevé, plus le temps de formation est long.
• TF-IDF :
  • Choisissez une vectorisation TF-IDF avec SVM si le jeu de données est petit, c'est-à-dire qu'il comporte un petit nombre de classes, un petit nombre d'exemples et une taille de texte plus courte, par exemple, des phrases contenant moins de phrases.
  • TF-IDF avec SVM peut être plus rapide que les autres algorithmes du bloc de classification.
  • Choisissez TF-IDF si les intégrations pour la langue requise ne sont pas disponibles.
• USE :
  • Sélectionnez Universal Sentence Encoder (USE) avec SVM si l'ensemble de données contient une ou plusieurs phrases dans le texte d'entrée.
  • L'USE peut mieux se produire sur des ensembles de données où il est important de comprendre le contexte des mots ou des phrases.

Le modèle Ensemble combine plusieurs modèles individuels (divers) pour fournir une puissance de prédiction supérieure. Tenez compte des données clés suivantes pour ce type de modèle :

• Le modèle d'ensemble combine CNN, SVM avec TF-IDF et SVM avec USE.
• C'est le modèle le plus facile à utiliser.
• Il peut donner de meilleures performances que les algorithmes individuels.
• Il fonctionne pour tous les types de jeux de données. Cependant, le temps de formation pour les grands ensembles de données (plus de 20000 exemples) peut être élevé.
• Un modèle d'ensemble vous permet de définir des pondérations. Ces pondérations déterminent la façon dont le modèle d'ensemble combine les résultats des discriminants individuels. Actuellement, la sélection des pondérations est une heuristique et doit être définie par essai et erreur. Les pondérations par défaut fournies dans la fonction elle-même constituent un bon point de départ pour l'exploration.

Rubrique parent : Création de vos propres modèles