Ausführliche Erläuterung von Funktionen wie Sequenzklassifizierung und IMDB-Filmbewertung

Sequenzklassifizierung, Vorhersage der Klassenbezeichnung der gesamten Eingabesequenz. Stimmungsanalyse zur Vorhersage der Themeneinstellung von Benutzern beim Schreiben von Texten. Vorhersage von Wahlergebnissen oder Produkt- oder Filmbewertungen.

Filmkritikdatensatz der International Movie Database. Der Zielwert ist binär, positiv oder negativ. Die Sprache enthält viel Verneinung, Ironie und Mehrdeutigkeit. Man kann nicht nur darauf schauen, ob ein Wort vorkommt. Erstellen Sie ein wiederkehrendes Wortvektornetzwerk, betrachten Sie jeden Kommentar Wort für Wort und trainieren Sie schließlich einen Klassifikator, um die Stimmung des gesamten Kommentars basierend auf dem Äußerungswert des Wortes vorherzusagen.

IMDB-Filmrezensionsdatensatz vom Stanford University Artificial Intelligence Laboratory: http://ai.stanford.edu/~amaas/data/sentiment/. Komprimierte TAR-Datei, positive und negative Kommentare werden aus zwei Ordnertextdateien abgerufen. Verwenden Sie reguläre Ausdrücke, um einfachen Text zu extrahieren und alle Buchstaben in Kleinbuchstaben umzuwandeln.

Die Darstellung der Wortvektoreinbettung ist semantischer als die One-Hot-Codierung von Wörtern. Das Vokabular ermittelt den Wortindex und findet den richtigen Wortvektor. Die Sequenzen werden auf die gleiche Länge aufgefüllt und mehrere Filmrezensionsdaten werden stapelweise an das Netzwerk gesendet.

Sequenzbeschriftungsmodell, übergeben Sie zwei Platzhalter, einer sind die Eingabedatendaten oder die Eingabesequenz und der andere ist der Zielwert, das Ziel oder die Emotion. Übergeben Sie den Konfigurationsparameter params object, Optimizer.

Dynamische Berechnung der aktuellen Batch-Datensequenzlänge. Die Daten liegen in Form eines einzelnen Tensors vor und jede Sequenz wird basierend auf der Länge der längsten Filmrezension mit Nullen aufgefüllt. Absolut maximale Reduzierung von Wortvektoren. Nullvektor, Skalar 0. Realer Wortvektor, Skalar größer als 0, reelle Zahl. tf.sign() ist diskret 0 oder 1. Die Ergebnisse werden entlang der Zeitschritte addiert, um die Sequenzlänge zu erhalten. Die Tensorlänge entspricht der Stapeldatenkapazität und der Skalar stellt die Sequenzlänge dar.

Verwenden Sie das params-Objekt, um den Einheitentyp und die Anzahl der Einheiten zu definieren. Das Längenattribut gibt die maximale Anzahl von Zeilen mit Batch-Daten an, die dem RNN bereitgestellt werden. Erhalten Sie den letzten Aktivitätswert jeder Sequenz und senden Sie ihn an die Softmax-Ebene. Da die Länge jeder Filmrezension unterschiedlich ist, hat der endgültige Korrelationsausgabeaktivitätswert jeder RNN-Sequenz in den Stapeldaten einen anderen Index. Erstellen Sie einen Index in der Zeitschrittdimension (Batchdatenformsequenzen*Zeitschritte*Wortvektoren). tf.gather() indiziert entlang der 1. Dimension. Die ersten beiden Dimensionen der Ausgabeaktivitätswertform sequences*time_steps*word_vectors werden abgeflacht und die Sequenzlänge wird hinzugefügt. Fügen Sie length-1 hinzu, um den letzten gültigen Zeitschritt auszuwählen.

Verlaufsbeschneidung, der Verlaufswert ist auf einen angemessenen Bereich begrenzt. Es kann jede sinnvolle Kostenfunktion in der Klasse verwendet werden, und die Modellausgabe kann in allen Wahrscheinlichkeitsverteilungen der Klasse verwendet werden. Fügen Sie Verlaufsbeschneidung hinzu, um die Lernergebnisse zu verbessern und maximale Gewichtsaktualisierungen zu begrenzen. Das RNN-Training ist schwierig, verschiedene Hyperparameter passen nicht richtig zusammen und die Gewichte weichen leicht voneinander ab.

TensorFlow unterstützt die Ableitung der Funktion „compute_gradients“ der Optimierungsinstanz, die Änderung von Farbverläufen und die Funktion „apply_gradients“ zum Anwenden von Gewichtsänderungen. Wenn die Gradientenkomponente kleiner als -limit ist, legen Sie -limit fest; wenn die Gradientenkomponente innerhalb des Limits liegt, legen Sie limit fest. Die TensorFlow-Ableitung kann None sein, was bedeutet, dass eine bestimmte Variable keine Beziehung zur Kostenfunktion hat. Mathematisch sollte es ein Nullvektor sein, aber None ist förderlich für die interne Leistungsoptimierung und nur der None-Wert muss zurückgegeben werden.

Die Filmkritiken werden Wort für Wort in das rekurrente neuronale Netzwerk eingespeist, und jeder Zeitschritt besteht aus Wortvektoren, die Stapeldaten bilden. Die Stapelfunktion findet Wortvektoren und vervollständigt alle Sequenzlängen. Trainieren Sie das Modell, definieren Sie Hyperparameter, laden Sie Datensätze und Wortvektoren und führen Sie das Modell mit vorverarbeiteten Trainingsstapeldaten aus. Das erfolgreiche Training des Modells hängt von der Netzwerkstruktur, den Hyperparametern und der Wortvektorqualität ab. Sie können vorab trainierte Wortvektoren aus dem Skip-Gram-Modell word2vec project ( ) und dem Glove-Modell der Stanford NLP-Forschungsgruppe (https://nlp.stanford.edu/projects/glove) laden.

Kaggle Open Learning Competition ( ), IMDB-Filmrezensionsdaten, Vorhersageergebnisse mit anderen vergleichen.

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

Referenzmaterial:
"TensorFlow Practice for Machine Intelligence"

Willkommen, mich auf WeChat hinzuzufügen, um zu kommunizieren: qingxingfengzi
Mein öffentliches WeChat-Konto: qingxingfengzigz
Das öffentliche WeChat-Konto meiner Frau Zhang Xingqing: qingqingfeifangz

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung von Funktionen wie Sequenzklassifizierung und IMDB-Filmbewertung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!