[DOCKER] [Apprentissage automatique] Classification de texte à l'aide du modèle Transformer (classificateur basé sur l'attention)

objectif

Modifier une partie du "Modèle Transformer pour la compréhension du langage" dans le didacticiel Tensorflow, Pour pouvoir effectuer des tâches de classification de texte.

Notebook J'ai téléchargé mon notebook sur Github. transformer_classify

Commentaire

Les principales différences par rapport au didacticiel sont répertoriées ci-dessous.

Les données utilisées sont le corpus d'actualités de Liveoor

――La tâche de classification introduite dans cet article est supposée être la classification des documents japonais lorsqu'elle est utilisée pour les entreprises. «Pour cette raison, nous avons utilisé le corpus d'actualités liveoor, qui est souvent utilisé dans l'apprentissage automatique.

Utilisez Human pour séparer les phrases

«Nous utilisons Human, qui a une bonne réputation pour écrire en japonais. --Cliquez ici pour le Dockerfile qui automatise le téléchargement et l'installation de Juman (https://github.com/raidenn-gh/dockerfile_tf2_py3_jpt_juman)

Suppression du décodeur

--Decoder est un mécanisme qui reçoit la sortie de Encoder et la convertit en un autre vecteur de langue.

• Cette fois, nous n'utiliserons pas Decoder car il s'agit d'une tâche de classification, pas d'une conversion vers un autre vecteur de langue.

Correction du transformateur

• Au lieu de supprimer Decoder, superposez la couche Dense sur la sortie obtenue par Encoder et ajoutez-la en tant que couche de sortie.
• Pour convertir le vecteur de texte d'entrée en une valeur qui exprime de manière probabiliste dans quelle classe il est classé. La fonction Softmax est utilisée comme fonction d'activation.

transformer_classify.ipynb

NUMLABELS = 9

class Transformer(tf.keras.Model):
  def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, 
               target_vocab_size, pe_input, pe_target, rate=0.1):
    super(Transformer, self).__init__()

    self.encoder = Encoder(num_layers, d_model, num_heads, dff, 
                           input_vocab_size, pe_input, rate)
    self.dense1 = tf.keras.layers.Dense(d_model, activation='tanh')
    self.dropout1 = tf.keras.layers.Dropout(rate)   
    self.final_layer = tf.keras.layers.Dense(NUMLABELS, activation='softmax')
        
  def call(self, inp, tar, training, enc_padding_mask):

    enc_output = self.encoder(inp, training, enc_padding_mask)  # (batch_size, inp_seq_len, d_model)
    enc_output = self.dense1(enc_output[:,0])
    enc_output = self.dropout1(enc_output, training=training)
    final_output = self.final_layer(enc_output )  # (batch_size, tar_seq_len, target_vocab_size)
    
    return final_output

Fonction de perte

• Puisque la fonction softmax est utilisée pour la fonction d'activation de la couche de sortie, l'entropie croisée multi-classes est utilisée pour la fonction de perte.
• Comme il n'est pas vectorisé à chaud, SparseCategoricalCrossentropy () est utilisé.

transformer_classify.ipynb

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()

def loss_function(labels, pred):
  loss_ = loss_object(labels, pred)
  return loss_

Ajout de val_step

--Val_step utilisant des données valides est ajouté après train_step. --Parce qu'il s'agit d'une validation, traininng est défini sur false pour ignorer la couche d'exclusion.

résultat

Je n'ai pas pu obtenir une très bonne précision.

URL de référence

tf2_classify BERT with SentencePiece for Japanese text. Faire et comprendre Transformer / Attention Transformer model for language understanding