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

Vous devez fournir un jeu de données d'entraînement et de développement à la fonction d'entraînement. Les données de développement représentent généralement environ 10% des données d'apprentissage. Chaque exemple d'entraînement ou de développement est représenté sous la forme d'un objet JSON. Il doit comporter un texte et une zone target_mentions . Le texte représente l'exemple de texte d'apprentissage et la zone target_mentions est un tableau, qui contient une entrée pour chaque mention cible avec son texte, emplacementet sentiment.

Envisagez d'utiliser Watson Knowledge Studio pour permettre à vos experts de domaine d'annoter facilement du texte et de créer des données d'apprentissage.

Voici un exemple de tableau avec des exemples de données d'apprentissage:

[
  {
    "text": "Those waiters stare at you your entire meal, just waiting for you to put your fork down and they snatch the plate away in a second.",
    "target_mentions": [
      {
        "text": "waiters",
        "location": {
          "begin": 6,
          "end": 13
        },
        "sentiment": "negative"
      }
    ]
  }
]

Les ensembles de données d'entraînement et de développement sont créés en tant que flux de données à partir de tableaux d'objets JSON. Pour créer les flux de données, vous pouvez utiliser la méthode d'utilitaire read_json_to_stream. Il requiert le modèle d'analyse syntaxique pour la langue de vos données d'entrée.

Exemple de code :

import watson_nlp
from watson_nlp.toolkit.targeted_sentiment.training_data_reader import read_json_to_stream

training_data_file = 'train_data.json'
dev_data_file = 'dev_data.json'

# Load the syntax analysis model for the language of your input data
syntax_model = watson_nlp.load('syntax_izumo_en_stock')

# Prepare train and dev data streams
train_stream = read_json_to_stream(json_path=training_data_file, syntax_model=syntax_model)
dev_stream = read_json_to_stream(json_path=dev_data_file, syntax_model=syntax_model)

Chargement des ressources de modèle préentraînées

Le modèle Slate IBM Foundation préentraîné doit être chargé avant de le transmettre à l'algorithme d'entraînement.

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

Pour charger le modèle:

# Load the pretrained Slate IBM Foundation model
pretrained_model_resource = watson_nlp.load('<pretrained Slate model>')

Entraînement du modèle

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

help(watson_nlp.blocks.targeted_sentiment.SequenceTransformerTSA.train)

La méthode train va créer un nouveau modèle de bloc de sentiment cible.

Voici un exemple d'appel qui utilise les données d'entrée et le modèle préentraîné de la section précédente (entraînement du modèle):

# Train the model
custom_tsa_model = watson_nlp.blocks.targeted_sentiment.SequenceTransformerTSA.train(
    train_stream,
    dev_stream,
    pretrained_model_resource,
    num_train_epochs=5
)

Application du modèle sur de nouvelles données

Après avoir entraîné le modèle sur un jeu de données, appliquez le modèle sur de nouvelles données à l'aide de la méthode run() , comme vous l'utiliseriez sur l'un des blocs pré-entraînés existants. Le modèle personnalisé créé étant un modèle de bloc, vous devez exécuter une analyse de syntaxe sur le texte d'entrée et transmettre les résultats aux méthodes run() .

Exemple de code :

input_text = 'new input text'

# Run syntax analysis first
syntax_model = watson_nlp.load('syntax_izumo_en_stock')
syntax_analysis = syntax_model.run(input_text, parsers=('token',))

# Apply the new model on top of the syntax predictions
tsa_predictions = custom_tsa_model.run(syntax_analysis)

Stockage et chargement du modèle

Le modèle de sentiment des cibles personnalisées peut être stocké comme n'importe quel autre modèle, comme décrit dans la rubrique Enregistrement et chargement de modèles personnalisés, à l'aide de ibm_watson_studio_lib.

Pour charger le modèle de sentiment des cibles personnalisées, des étapes supplémentaires sont requises:

1. Vérifiez que vous disposez d'un jeton d'accès sur la page Contrôle d'accès de l'onglet Gérer de votre projet. Seuls les administrateurs de projet peuvent créer des jetons d'accès. Le jeton d'accès peut disposer des droits d'accès Afficheur ou Editeur . Seuls les éditeurs peuvent injecter le jeton dans un bloc-notes.

2. Ajoutez le jeton de projet au bloc-notes en cliquant sur Plus > Insérer un jeton de projet dans la barre d'actions du bloc-notes. Exécutez ensuite la cellule.

   En exécutant la cellule de code masquée insérée, vous créez un objet wslib que vous pouvez utiliser pour les fonctions de la bibliothèque ibm-watson-studio-lib . Pour plus d'informations sur les fonctions ibm-watson-studio-lib disponibles, voir Utilisation d'ibm-watson-studio-lib pour Python.

3. Téléchargez et extrayez le modèle dans votre environnement d'exécution local:

   import zipfile
   model_zip = 'custom_TSA_model_file'
   model_folder = 'custom_TSA'
   wslib.download_file('custom_TSA_model', file_name=model_zip)
   
   with zipfile.ZipFile(model_zip, 'r') as zip_ref:
     zip_ref.extractall(model_folder)
   

4. Chargez le modèle à partir du dossier extrait:

   custom_TSA_model = watson_nlp.load(model_folder)
   

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