Étape 4: Créer, entraîner et évaluer votre modèle

Dans cette section, nous allons créer, former et évaluer dans un modèle de ML. À l'étape 3, nous nous avons choisi d'utiliser un modèle de n-grammes ou de séquence avec notre ratio S/W. Il est maintenant temps d'écrire notre algorithme de classification et de l'entraîner. Nous utiliserons TensorFlow avec tf.keras pour cela.

Créer des modèles de machine learning avec Keras consiste à assembler des modèles des couches, des blocs de construction pour le traitement des données, un peu comme si nous assemblerions des Lego de briques. Ces couches nous permettent de spécifier la séquence de transformations souhaitée. à effectuer sur notre entrée. Comme notre algorithme d'apprentissage accepte une seule entrée de texte et génère une classification unique, nous pouvons créer une pile linéaire de couches à l'aide du Modèle séquentiel API.

Figure 9: Pile linéaire de calques

La couche d'entrée et les couches intermédiaires seront construites différemment, selon que nous construisons un modèle de N-grammes ou de séquence. Toutefois, quel que soit le type de modèle, la dernière couche est la même pour un problème donné.

Construire la dernière couche

Lorsque nous n'avons que deux classes (classification binaire), notre modèle doit générer une score de probabilité unique. Par exemple, générer 0.2 pour un échantillon d'entrée donné. signifie « de confiance de 20% que cet échantillon se trouve dans la première classe (classe 1), 80% que elle se trouve dans la deuxième classe (classe 0)." Pour obtenir un tel score de probabilité, fonction d'activation de la dernière couche doit être fonction sigmoïde, et fonction de perte pour entraîner le modèle doit être entropie croisée binaire. (voir la Figure 10, à gauche).

Lorsqu'il y a plus de deux classes (classification à classes multiples), notre modèle doit générer un score de probabilité par classe. La somme de ces scores doit être 1. Par exemple, la sortie {0: 0.2, 1: 0.7, 2: 0.1} signifie "un taux de confiance de 20 % Cet échantillon appartient à la classe 0, 70% à la classe 1 et 10% à la classe 1 classe 2." Pour générer ces scores, la fonction d'activation de la dernière couche doit être softmax, et la fonction de perte utilisée pour entraîner le modèle doit être l'entropie croisée catégorielle. (voir la Figure 10, à droite).

Figure 10: Dernière couche

Le code suivant définit une fonction qui accepte en entrée le nombre de classes, et génère le nombre approprié d'unités de couche (1 pour les unités binaires) la classification ; sinon 1 unité pour chaque classe) et l'activation appropriée :

def _get_last_layer_units_and_activation(num_classes):
    """Gets the # units and activation function for the last network layer.

    # Arguments
        num_classes: int, number of classes.

    # Returns
        units, activation values.
    """
    if num_classes == 2:
        activation = 'sigmoid'
        units = 1
    else:
        activation = 'softmax'
        units = num_classes
    return units, activation

Les deux sections suivantes expliquent comment créer le modèle restant pour les modèles de n-grammes et de séquences.

Lorsque le ratio S/W est faible, nous avons constaté que les modèles de n-grammes sont plus performants que les modèles de séquence. Les modèles de séquence sont plus efficaces lorsqu'il existe un grand nombre de petits vecteurs denses. En effet, les relations de représentation vectorielle continue sont apprises un espace dense, ce qui se produit plus efficacement sur de nombreux échantillons.

Créer un modèle de n-grammes [Option A]

Il s'agit de modèles qui traitent les jetons de manière indépendante (sans tenir compte l'ordre des mots du compte) en tant que modèles de n-grammes. Perceptrons à plusieurs couches simples (y compris Régression logistique machines d'optimisation de gradient, et prennent en charge les modèles de machines vectorielles) relèvent toutes de cette catégorie ; il ne peut utiliser aucune information sur l’ordre des textes.

Nous avons comparé les performances de certains des modèles de N-grammes mentionnés ci-dessus et observé que les perceptrons multicouches (MLP) sont généralement plus performants que d'autres options. Les MLP sont simples à définir et à comprendre, offrent une bonne justesse, et nécessitent relativement peu de calculs.

Le code suivant définit un modèle MLP à deux couches dans tf.keras, en ajoutant quelques Couches d'abandon pour la régularisation pour éviter surapprentissage aux échantillons d'entraînement.

from tensorflow.python.keras import models
from tensorflow.python.keras.layers import Dense
from tensorflow.python.keras.layers import Dropout

def mlp_model(layers, units, dropout_rate, input_shape, num_classes):
    """Creates an instance of a multi-layer perceptron model.

    # Arguments
        layers: int, number of `Dense` layers in the model.
        units: int, output dimension of the layers.
        dropout_rate: float, percentage of input to drop at Dropout layers.
        input_shape: tuple, shape of input to the model.
        num_classes: int, number of output classes.

    # Returns
        An MLP model instance.
    """
    op_units, op_activation = _get_last_layer_units_and_activation(num_classes)
    model = models.Sequential()
    model.add(Dropout(rate=dropout_rate, input_shape=input_shape))

    for _ in range(layers-1):
        model.add(Dense(units=units, activation='relu'))
        model.add(Dropout(rate=dropout_rate))

    model.add(Dense(units=op_units, activation=op_activation))
    return model

Créer un modèle de séquence [Option B]

Nous faisons référence à des modèles qui peuvent apprendre de la contiguïté des jetons en tant que séquence des modèles de ML. Cela inclut les classes de modèles CNN et RNN. Les données sont prétraitées des vecteurs de séquence pour ces modèles.

Les modèles de séquence ont généralement un plus grand nombre de paramètres à apprendre. Le premier de ces modèles est une couche de représentation vectorielle continue, qui apprend la relation entre les mots dans un espace vectoriel dense. Apprendre des relations entre mots sur de nombreux échantillons.

Les mots d'un jeu de données ne sont probablement pas uniques à ce jeu de données. Nous pouvons ainsi apprendre la relation entre les mots de notre ensemble de données en utilisant un ou plusieurs autres ensembles de données. Pour ce faire, nous pouvons transférer une représentation vectorielle continue apprise d'un autre ensemble de données dans notre la couche de représentation vectorielle continue. Ces représentations vectorielles continues sont appelées pré-entraînés représentations vectorielles continues. L'utilisation d'une représentation vectorielle continue pré-entraînée permet au modèle de prendre une longueur d'avance dans la de machine learning.

Il existe des représentations vectorielles continues pré-entraînées qui ont été entraînées à l'aide de grandes corpus, tel que GloVe. GloVe propose ont été entraînés sur plusieurs corpus (principalement Wikipédia). Nous avons testé l'entraînement des modèles séquentiels à l'aide d'une version de représentations vectorielles continues GloVe et nous avons observé a figé les pondérations des représentations vectorielles continues pré-entraînées et n'a entraîné que le reste des les modèles n'ont pas été performants. Cela peut être dû au fait que le contexte pour laquelle la couche de représentation vectorielle continue a été entraînée peut être différent du contexte dans lequel nous l'utilisions.

Il est possible que les représentations vectorielles continues GloVe entraînées à partir de données Wikipédia ne correspondent pas à la langue. des modèles dans notre jeu de données IMDb. Les relations déduites peuvent nécessiter la mise à jour, c'est-à-dire que les pondérations des représentations vectorielles continues peuvent nécessiter un réglage contextuel. Nous le faisons dans en deux étapes:

1. Lors de la première exécution, avec les pondérations de la couche de représentation vectorielle continue figées, nous autorisons le reste du réseau à apprendre. À la fin de cette exécution, les pondérations du modèle atteignent un état bien mieux que leurs valeurs non initialisées. Pour la deuxième exécution, permettent également à la couche de représentation vectorielle continue d'apprendre, ce qui permet d'ajuster précisément toutes les pondérations du réseau. Nous appelons ce processus l'utilisation d'une représentation vectorielle continue affinée.

2. Les représentations vectorielles continues affinées offrent une meilleure précision. Cependant, cela arrive au l'augmentation de la puissance de calcul nécessaire à l'entraînement du réseau. Avec un un nombre suffisant d'échantillons, nous pourrions tout aussi bien apprendre une représentation vectorielle continue en partant de zéro. Nous avons observé que, pour S/W > 15K, partir de zéro efficacement offre la même précision qu'avec une intégration affinée.

Nous avons comparé différents modèles de séquence tels que CNN, sepCNN, RNN (LSTM et GRU), CNN-RNN et RNN empilé, en variant les valeurs d'architectures de modèles. Nous avons constaté que sepCNN, une variante de réseau convolutif qui est souvent plus économe en données et en calcul, est plus efficace que avec d'autres modèles.

Le code suivant construit un modèle sepCNN à quatre couches:

from tensorflow.python.keras import models
from tensorflow.python.keras import initializers
from tensorflow.python.keras import regularizers

from tensorflow.python.keras.layers import Dense
from tensorflow.python.keras.layers import Dropout
from tensorflow.python.keras.layers import Embedding
from tensorflow.python.keras.layers import SeparableConv1D
from tensorflow.python.keras.layers import MaxPooling1D
from tensorflow.python.keras.layers import GlobalAveragePooling1D

def sepcnn_model(blocks,
                 filters,
                 kernel_size,
                 embedding_dim,
                 dropout_rate,
                 pool_size,
                 input_shape,
                 num_classes,
                 num_features,
                 use_pretrained_embedding=False,
                 is_embedding_trainable=False,
                 embedding_matrix=None):
    """Creates an instance of a separable CNN model.

    # Arguments
        blocks: int, number of pairs of sepCNN and pooling blocks in the model.
        filters: int, output dimension of the layers.
        kernel_size: int, length of the convolution window.
        embedding_dim: int, dimension of the embedding vectors.
        dropout_rate: float, percentage of input to drop at Dropout layers.
        pool_size: int, factor by which to downscale input at MaxPooling layer.
        input_shape: tuple, shape of input to the model.
        num_classes: int, number of output classes.
        num_features: int, number of words (embedding input dimension).
        use_pretrained_embedding: bool, true if pre-trained embedding is on.
        is_embedding_trainable: bool, true if embedding layer is trainable.
        embedding_matrix: dict, dictionary with embedding coefficients.

    # Returns
        A sepCNN model instance.
    """
    op_units, op_activation = _get_last_layer_units_and_activation(num_classes)
    model = models.Sequential()

    # Add embedding layer. If pre-trained embedding is used add weights to the
    # embeddings layer and set trainable to input is_embedding_trainable flag.
    if use_pretrained_embedding:
        model.add(Embedding(input_dim=num_features,
                            output_dim=embedding_dim,
                            input_length=input_shape[0],
                            weights=[embedding_matrix],
                            trainable=is_embedding_trainable))
    else:
        model.add(Embedding(input_dim=num_features,
                            output_dim=embedding_dim,
                            input_length=input_shape[0]))

    for _ in range(blocks-1):
        model.add(Dropout(rate=dropout_rate))
        model.add(SeparableConv1D(filters=filters,
                                  kernel_size=kernel_size,
                                  activation='relu',
                                  bias_initializer='random_uniform',
                                  depthwise_initializer='random_uniform',
                                  padding='same'))
        model.add(SeparableConv1D(filters=filters,
                                  kernel_size=kernel_size,
                                  activation='relu',
                                  bias_initializer='random_uniform',
                                  depthwise_initializer='random_uniform',
                                  padding='same'))
        model.add(MaxPooling1D(pool_size=pool_size))

    model.add(SeparableConv1D(filters=filters * 2,
                              kernel_size=kernel_size,
                              activation='relu',
                              bias_initializer='random_uniform',
                              depthwise_initializer='random_uniform',
                              padding='same'))
    model.add(SeparableConv1D(filters=filters * 2,
                              kernel_size=kernel_size,
                              activation='relu',
                              bias_initializer='random_uniform',
                              depthwise_initializer='random_uniform',
                              padding='same'))
    model.add(GlobalAveragePooling1D())
    model.add(Dropout(rate=dropout_rate))
    model.add(Dense(op_units, activation=op_activation))
    return model

Entraîner le modèle

Maintenant que nous avons construit l'architecture du modèle, nous devons l'entraîner. L'entraînement implique d'effectuer une prédiction basée sur l'état actuel du modèle, calculer le degré d'erreur de la prédiction et mettre à jour les pondérations du réseau pour minimiser l'erreur et permettre au modèle de prédire mieux encore. Nous répétons ce processus jusqu'à ce que le modèle converge et ne puisse plus apprendre. Vous devez choisir trois paramètres clés pour ce processus (voir Tableau 2).

• Métrique: comment mesurer les performances du modèle à l'aide d'un metric. Nous avons utilisé la précision dans nos tests.
• Fonction de perte: fonction utilisée pour calculer une valeur de perte que le processus d'entraînement tente ensuite de minimiser en ajustant les pondérations de réseau. Pour les problèmes de classification, la perte d'entropie croisée fonctionne bien.
• Optimizer: fonction qui détermine la façon dont les pondérations du réseau seront mis à jour en fonction de la sortie de la fonction de perte. Nous avons utilisé les technologies Adam dans nos tests.

Dans Keras, nous pouvons transmettre ces paramètres d'apprentissage à un modèle en utilisant compiler .

Tableau 2: Paramètres d'apprentissage

L'entraînement est effectué à l'aide fit. Selon la taille de votre il s'agit de la méthode utilisée pour la plupart des cycles de calcul. Dans chaque itération d'entraînement, batch_size d'échantillons de vos données d'entraînement sont utilisées pour calculer la perte, et les pondérations sont mises à jour une seule fois, en fonction de cette valeur. Le processus d'entraînement termine une epoch une fois que le modèle a vu l'intégralité un ensemble de données d'entraînement. À la fin de chaque époque, nous utilisons l'ensemble de données de validation et d'évaluer la qualité de son apprentissage. Nous répétons l'entraînement avec l'ensemble de données. pendant un nombre d'époques prédéterminé. Nous pouvons optimiser cela en arrêtant prématurément, lorsque la justesse de la validation se stabilise entre deux époques consécutives, ce qui montre le modèle ne s'entraîne plus.

Tableau 3: Hyperparamètres d'entraînement

Le code Keras suivant met en œuvre le processus d'entraînement à l'aide des paramètres choisies dans les tableaux 2 et 3 ci-dessus:

def train_ngram_model(data,
                      learning_rate=1e-3,
                      epochs=1000,
                      batch_size=128,
                      layers=2,
                      units=64,
                      dropout_rate=0.2):
    """Trains n-gram model on the given dataset.

    # Arguments
        data: tuples of training and test texts and labels.
        learning_rate: float, learning rate for training model.
        epochs: int, number of epochs.
        batch_size: int, number of samples per batch.
        layers: int, number of `Dense` layers in the model.
        units: int, output dimension of Dense layers in the model.
        dropout_rate: float: percentage of input to drop at Dropout layers.

    # Raises
        ValueError: If validation data has label values which were not seen
            in the training data.
    """
    # Get the data.
    (train_texts, train_labels), (val_texts, val_labels) = data

    # Verify that validation labels are in the same range as training labels.
    num_classes = explore_data.get_num_classes(train_labels)
    unexpected_labels = [v for v in val_labels if v not in range(num_classes)]
    if len(unexpected_labels):
        raise ValueError('Unexpected label values found in the validation set:'
                         ' {unexpected_labels}. Please make sure that the '
                         'labels in the validation set are in the same range '
                         'as training labels.'.format(
                             unexpected_labels=unexpected_labels))

    # Vectorize texts.
    x_train, x_val = vectorize_data.ngram_vectorize(
        train_texts, train_labels, val_texts)

    # Create model instance.
    model = build_model.mlp_model(layers=layers,
                                  units=units,
                                  dropout_rate=dropout_rate,
                                  input_shape=x_train.shape[1:],
                                  num_classes=num_classes)

    # Compile model with learning parameters.
    if num_classes == 2:
        loss = 'binary_crossentropy'
    else:
        loss = 'sparse_categorical_crossentropy'
    optimizer = tf.keras.optimizers.Adam(lr=learning_rate)
    model.compile(optimizer=optimizer, loss=loss, metrics=['acc'])

    # Create callback for early stopping on validation loss. If the loss does
    # not decrease in two consecutive tries, stop training.
    callbacks = [tf.keras.callbacks.EarlyStopping(
        monitor='val_loss', patience=2)]

    # Train and validate model.
    history = model.fit(
            x_train,
            train_labels,
            epochs=epochs,
            callbacks=callbacks,
            validation_data=(x_val, val_labels),
            verbose=2,  # Logs once per epoch.
            batch_size=batch_size)

    # Print results.
    history = history.history
    print('Validation accuracy: {acc}, loss: {loss}'.format(
            acc=history['val_acc'][-1], loss=history['val_loss'][-1]))

    # Save model.
    model.save('IMDb_mlp_model.h5')
    return history['val_acc'][-1], history['val_loss'][-1]

Pour trouver des exemples de code pour l'entraînement du modèle de séquence, cliquez ici.