Explication détaillée de fonctions telles que la classification des séquences et la classification des films IMDB

Classification des séquences, prédisez l'étiquette de classe de toute la séquence d'entrée. Analyse des sentiments pour prédire l'attitude des utilisateurs à l'égard du sujet lors de la rédaction d'un texte. Prédire les résultats des élections ou les évaluations de produits ou de films.

Ensemble de données sur les critiques de films de la base de données internationale sur les films. La valeur cible est binaire, positive ou négative. Le langage contient beaucoup de négation, d’ironie et d’ambiguïté. On ne peut pas simplement regarder si un mot apparaît. Construisez un réseau récurrent de vecteurs de mots, visualisez chaque commentaire mot par mot et enfin entraînez un classificateur pour prédire le sentiment de l'ensemble du commentaire en fonction de la valeur d'énoncé du mot.

Ensemble de données de critiques de films IMDB du laboratoire d'intelligence artificielle de l'université de Stanford : http://ai.stanford.edu/~amaas/data/sentiment/. Fichier tar compressé, les commentaires positifs et négatifs sont obtenus à partir de deux fichiers texte de dossiers. Utilisez des expressions régulières pour extraire du texte brut et convertir toutes les lettres en minuscules.

La représentation d'intégration de vecteurs de mots est plus riche en sémantique que les mots codés à chaud. Le vocabulaire détermine l'index des mots et trouve le bon vecteur de mots. Les séquences sont complétées à la même longueur et plusieurs données de critiques de films sont envoyées au réseau par lots.

Modèle d'étiquetage de séquence, transmettez deux espaces réservés, l'un est les données d'entrée ou la séquence, et l'autre est la valeur cible, la cible ou l'émotion. Passez l'objet params du paramètre de configuration, optimiseur.

Calcul dynamique de la longueur actuelle de la séquence de données du lot. Les données se présentent sous la forme d'un tenseur unique et chaque séquence est complétée par des 0 en fonction de la durée de la critique de film la plus longue. Réduction maximale absolue des vecteurs de mots. Vecteur zéro, scalaire 0. Vecteur de mot réel, scalaire supérieur à 0 nombre réel. tf.sign() est discrètement 0 ou 1. Les résultats sont ajoutés au fil des pas de temps pour obtenir la longueur de la séquence. La longueur du tenseur est la même que la capacité des données du lot et le scalaire représente la longueur de la séquence.

Utilisez l'objet params pour définir le type d'unité et le nombre d'unités. L'attribut length spécifie le nombre maximum de lignes de données par lots fournies au RNN. Obtenez la dernière valeur d'activité de chaque séquence et envoyez-la à la couche softmax. Étant donné que la durée de chaque critique de film est différente, la valeur finale de l'activité de sortie de corrélation de chaque séquence de RNN dans les données par lots a un indice différent. Créez un index dans la dimension de pas de temps (séquences de forme de données par lots*time_steps*word_vectors). tf.gather() indexe le long de la 1ère dimension. Les deux premières dimensions de la forme de la valeur d'activité de sortie séquences*time_steps*word_vectors sont aplaties et la longueur de la séquence est ajoutée. Ajoutez length-1 pour sélectionner le dernier pas de temps valide.

Dégradé, la valeur du dégradé est limitée à une plage raisonnable. N'importe quelle fonction de coût significative dans la classe peut être utilisée, et les résultats du modèle peuvent être utilisés dans toutes les distributions de probabilité de classe. Ajoutez un découpage de dégradé pour améliorer les résultats d’apprentissage et limiter les mises à jour de poids maximum. La formation RNN est difficile, les différents hyper-paramètres ne correspondent pas correctement et les poids peuvent facilement diverger.

TensorFlow prend en charge la déduction de la fonction computation_gradients de l'instance d'optimiseur, la modification des dégradés et la fonction apply_gradients pour appliquer les changements de poids. Si la composante du dégradé est inférieure à -limit, définissez -limit ; si la composante du dégradé est dans la limite, définissez la limite. La dérivée TensorFlow peut être None, ce qui signifie qu'une certaine variable n'a aucune relation avec la fonction de coût. Mathématiquement, elle doit être un vecteur nul, mais None est propice à l'optimisation des performances internes et seule la valeur None doit être renvoyée.

Les critiques de films sont introduites mot par mot dans le réseau neuronal récurrent, et chaque pas de temps est constitué de vecteurs de mots formant des données par lots. La fonction par lots recherche les vecteurs de mots et complète toutes les longueurs de séquence. Entraînez le modèle, définissez des hyperparamètres, chargez des ensembles de données et des vecteurs de mots, et exécutez le modèle sur des données de lots d'entraînement prétraitées. La réussite de la formation du modèle dépend de la structure du réseau, des hyperparamètres et de la qualité du vecteur de mots. Vous pouvez charger des vecteurs de mots pré-entraînés à partir du projet word2vec du modèle skip-gram ( ) et du modèle Glove du groupe de recherche Stanford NLP (https://nlp.stanford.edu/projects/glove).

Kaggle Open Learning Competition ( ), données de critiques de films IMDB, comparez les résultats des prédictions avec d'autres.

    import tarfileimport refrom helpers import downloadclass ImdbMovieReviews:

        DEFAULT_URL = \'http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz'TOKEN_REGEX = re.compile(r'[A-Za-z]+|[!?.:,()]')def __init__(self, cache_dir, url=None):
        self._cache_dir = cache_dir
        self._url = url or type(self).DEFAULT_URLdef __iter__(self):
            filepath = download(self._url, self._cache_dir)
            with tarfile.open(filepath) as archive:for filename in archive.getnames():if filename.startswith('aclImdb/train/pos/'):yield self._read(archive, filename), Trueelif filename.startswith('aclImdb/train/neg/'):yield self._read(archive, filename), Falsedef _read(self, archive, filename):
            with archive.extractfile(filename) as file_:
                data = file_.read().decode('utf-8')
                data = type(self).TOKEN_REGEX.findall(data)
                data = [x.lower() for x in data]return dataimport bz2import numpy as npclass Embedding:def __init__(self, vocabulary_path, embedding_path, length):
            self._embedding = np.load(embedding_path)
            with bz2.open(vocabulary_path, 'rt') as file_:
                self._vocabulary = {k.strip(): i for i, k in enumerate(file_)}
            self._length = lengthdef __call__(self, sequence):
            data = np.zeros((self._length, self._embedding.shape[1]))
            indices = [self._vocabulary.get(x, 0) for x in sequence]
            embedded = self._embedding[indices]
            data[:len(sequence)] = embeddedreturn data

        @propertydef dimensions(self):return self._embedding.shape[1]import tensorflow as tffrom helpers import lazy_propertyclass SequenceClassificationModel:def __init__(self, data, target, params):
            self.data = data
            self.target = target
            self.params = params
            self.prediction
            self.cost
            self.error
            self.optimize

        @lazy_propertydef length(self):
            used = tf.sign(tf.reduce_max(tf.abs(self.data), reduction_indices=2))
            length = tf.reduce_sum(used, reduction_indices=1)
            length = tf.cast(length, tf.int32)return length

        @lazy_propertydef prediction(self):# Recurrent network.output, _ = tf.nn.dynamic_rnn(
                self.params.rnn_cell(self.params.rnn_hidden),
                self.data,
                dtype=tf.float32,
                sequence_length=self.length,
            )
            last = self._last_relevant(output, self.length)# Softmax layer.num_classes = int(self.target.get_shape()[1])
            weight = tf.Variable(tf.truncated_normal(
                [self.params.rnn_hidden, num_classes], stddev=0.01))
            bias = tf.Variable(tf.constant(0.1, shape=[num_classes]))
            prediction = tf.nn.softmax(tf.matmul(last, weight) + bias)return prediction

        @lazy_propertydef cost(self):
            cross_entropy = -tf.reduce_sum(self.target * tf.log(self.prediction))return cross_entropy

        @lazy_propertydef error(self):
            mistakes = tf.not_equal(
                tf.argmax(self.target, 1), tf.argmax(self.prediction, 1))return tf.reduce_mean(tf.cast(mistakes, tf.float32))

        @lazy_propertydef optimize(self):
            gradient = self.params.optimizer.compute_gradients(self.cost)try:
                limit = self.params.gradient_clipping
                gradient = [
                    (tf.clip_by_value(g, -limit, limit), v)if g is not None else (None, v)for g, v in gradient]except AttributeError:print('No gradient clipping parameter specified.')
            optimize = self.params.optimizer.apply_gradients(gradient)return optimize

        @staticmethoddef _last_relevant(output, length):
            batch_size = tf.shape(output)[0]
            max_length = int(output.get_shape()[1])
            output_size = int(output.get_shape()[2])
            index = tf.range(0, batch_size) * max_length + (length - 1)
            flat = tf.reshape(output, [-1, output_size])
            relevant = tf.gather(flat, index)return relevantimport tensorflow as tffrom helpers import AttrDictfrom Embedding import Embeddingfrom ImdbMovieReviews import ImdbMovieReviewsfrom preprocess_batched import preprocess_batchedfrom SequenceClassificationModel import SequenceClassificationModel

    IMDB_DOWNLOAD_DIR = './imdb'WIKI_VOCAB_DIR = '../01_wikipedia/wikipedia'WIKI_EMBED_DIR = '../01_wikipedia/wikipedia'params = AttrDict(
        rnn_cell=tf.contrib.rnn.GRUCell,
        rnn_hidden=300,
        optimizer=tf.train.RMSPropOptimizer(0.002),
        batch_size=20,
    )

    reviews = ImdbMovieReviews(IMDB_DOWNLOAD_DIR)
    length = max(len(x[0]) for x in reviews)

    embedding = Embedding(
        WIKI_VOCAB_DIR + '/vocabulary.bz2',
        WIKI_EMBED_DIR + '/embeddings.npy', length)
    batches = preprocess_batched(reviews, length, embedding, params.batch_size)

    data = tf.placeholder(tf.float32, [None, length, embedding.dimensions])
    target = tf.placeholder(tf.float32, [None, 2])
    model = SequenceClassificationModel(data, target, params)

    sess = tf.Session()
    sess.run(tf.initialize_all_variables())for index, batch in enumerate(batches):
        feed = {data: batch[0], target: batch[1]}
        error, _ = sess.run([model.error, model.optimize], feed)print('{}: {:3.1f}%'.format(index + 1, 100 * error))

Matériel de référence :
"TensorFlow Practice for Machine Intelligence"

Bienvenue pour m'ajouter sur WeChat pour communiquer : qingxingfengzi
Mon ​​compte public WeChat : qingxingfengzigz
Le compte public WeChat de ma femme Zhang Xingqing : qingqingfeifangz

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!