Grob gesagt

Textklassifizierung mit Convolutional Neural Networks (CNN).
Faltungsneurale Netze zur Satzklassifizierung wurde in Chainer implementiert.
[Chainer] Dokumentklassifizierung nach Faltungsnetzwerk konnte Texte mit einer höheren Genauigkeitsrate klassifizieren.

Einführung

[Convolutional Neural Networks for Satzklassifizierung](http: /), angekündigt auf der EMNLP 2014 als Fortsetzung der zuvor veröffentlichten [Chainer] Document Classification by Convolutional Neural Networks. /emnlp2014.org/papers/pdf/EMNLP2014181.pdf) wurde in Chainer implementiert.

GitHub des Autors veröffentlicht ebenfalls eine Implementierung mit Theano.

Der diesmal entwickelte Quellcode ist hier verfügbar: chainer-cnnsc

Verwendete Daten

-Daten finden Sie unter hier. Ich habe "Satzpolaritätsdatensatz v1.0" verwendet.

Direkter Download

Vorbereitungen

--Installation von Chainer, Scikit-Learn, Gensim

Download des trainierten Modells von word2vec (GoogleNews-vectors-negative300.bin.gz).

Umgebung

Chainer
Python 2.7-Serie

Trainingsdaten

Verwenden Sie englische Textdaten. Bitte beziehen Sie die Textdaten vom oben genannten Download-Ziel. Jede Zeile entspricht einem Dokument. Die erste Spalte ist die Beschriftung und die zweite und die nachfolgenden Spalten sind der Text. Etiketten 0 sind negative Dokumente und 1 sind positive Dokumente.

[Etikette] [Text(Raumbegrenzer halber Breite)]
0 it just didn't mean much to me and played too skewed to ever get a hold on ( or be entertained by ) .
1 culkin , who's in virtually every scene , shines as a young man who uses sarcastic lies like a shield .
...

Modell-

Dieses Mal habe ich das in diesem Artikel vorgeschlagene Modell verwendet (Faltungsneurale Netze zur Satzklassifizierung). Eine Beschreibung des Modells finden Sie in diesem Artikel.

Modell unter Verwendung eines Faltungsnetzwerks in der Verarbeitung natürlicher Sprache

CNNMODEL

Programm (Netzwerkteil)

In dem Programm werden mehrere Filtergrößen für die Faltung definiert, und die Faltung wird für jeden Filter durchgeführt. Die definierte Filtergröße wird in filter_height im Listenformat gespeichert. Zur Vorwärtsausbreitung wird die Schleife für jede Filtergröße gedreht, um eine Faltung wie unten gezeigt durchzuführen.

 #Drehen Sie die Schleife für jeden Filtertyp
 for i, filter_size in enumerate(self.filter_height):
     #Durch die Faltungsschicht
     h_conv[i] = F.relu(self[i](x))
     #Durch die Pooling-Ebene
     h_pool[i] = F.max_pooling_2d(h_conv[i], (self.max_sentence_len+1-filter_size))

Der Quellcode des Netzwerkteils wird unten angezeigt.

#Ich möchte die Anzahl der Links variabel machen, also verwende ich ChainList
class CNNSC(ChainList):
    def __init__(self,
                 input_channel,
                 output_channel,
                 filter_height,
                 filter_width,
                 n_label,
                 max_sentence_len):
        #Die Anzahl der Filter, die Höhe der verwendeten Filter und die maximale Satzlänge werden später verwendet.
        self.cnv_num = len(filter_height)
        self.filter_height = filter_height
        self.max_sentence_len = max_sentence_len
        
        #Link für Faltungsebene für jeden Filter hinzugefügt
        # Convolution2D(Anzahl der Eingangskanäle,Anzahl der Ausgangskanäle (Anzahl der Filter für jede Form),Filterform (im Tapple-Format),Polstergröße)
        link_list = [L.Convolution2D(input_channel, output_channel, (i, filter_width), pad=0) for i in filter_height]
        #Link für Dropoff hinzugefügt
        link_list += [L.Linear(output_channel * self.cnv_num, output_channel * self.cnv_num)]
        #Link zur Ausgabeebene hinzugefügt
        link_list += [L.Linear(output_channel * self.cnv_num, n_label)]

        #Initialisieren Sie die Klasse anhand der Liste der bisher definierten Links
        super(CNNSC, self).__init__(*link_list)
        
        #Apropos
        # self.add_link(link)
        #Es ist in Ordnung, die Links aufzulisten und wie folgt einzeln hinzuzufügen

    def __call__(self, x, train=True):
        #Bereiten Sie die gefilterte Zwischenschicht vor
        h_conv = [None for _ in self.filter_height]
        h_pool = [None for _ in self.filter_height]
        
        #Drehen Sie die Schleife für jeden Filtertyp
        for i, filter_size in enumerate(self.filter_height):
            #Durch die Faltungsschicht
            h_conv[i] = F.relu(self[i](x))
            #Durch die Pooling-Ebene
            h_pool[i] = F.max_pooling_2d(h_conv[i], (self.max_sentence_len+1-filter_size))
        # Convolution+Kombinieren Sie die Ergebnisse des Pooling
        concat = F.concat(h_pool, axis=2)
        #Löschen Sie das kombinierte Ergebnis
        h_l1 = F.dropout(F.tanh(self[self.cnv_num+0](concat)),ratio=0.5,train=train)
        #Komprimieren Sie das Dropout-Ergebnis in die Ausgabeebene
        y = self[self.cnv_num+1](h_l1)

        return y

Versuchsergebnis

In dem Experiment wurde der Datensatz in Trainingsdaten und Testdaten unterteilt, und 50 Epochen wurden für das Training gedreht. Die korrekte Antwortrate für die Testdaten war die 50. Epoche, die "Genauigkeit = 0,799437701702" war.

Dieser Artikel war beim Klassifizieren von Dokumenten mit einem Modell unter Verwendung eines einfacheren CNN "Genauigkeit = 0,775624996424", sodass die korrekte Antwortrate geringfügig ist Wurde gefunden, um sich zu verbessern.

input file name: dataset/mr_input.dat
loading word2vec model...
height (max length of sentences): 59
width (size of wordembedding vecteor ): 300
epoch 1 / 50
train mean loss=0.568159639835, accuracy=0.707838237286
 test mean loss=0.449375987053, accuracy=0.788191199303
epoch 2 / 50
train mean loss=0.422049582005, accuracy=0.806962668896
 test mean loss=0.4778624475, accuracy=0.777881920338
epoch 3 / 50
train mean loss=0.329617649317, accuracy=0.859808206558
 test mean loss=0.458206892014, accuracy=0.792877197266
epoch 4 / 50
train mean loss=0.240891501307, accuracy=0.90389829874
 test mean loss=0.642955899239, accuracy=0.769447028637
 ...
epoch 47 / 50
train mean loss=0.000715514877811, accuracy=0.999791562557
 test mean loss=0.910120248795, accuracy=0.799437701702
epoch 48 / 50
train mean loss=0.000716249051038, accuracy=0.999791562557
 test mean loss=0.904825389385, accuracy=0.801312088966
epoch 49 / 50
train mean loss=0.000753249507397, accuracy=0.999791562557
 test mean loss=0.900236129761, accuracy=0.799437701702
epoch 50 / 50
train mean loss=0.000729961204343, accuracy=0.999791562557
 test mean loss=0.892229259014, accuracy=0.799437701702

abschließend

In diesem Artikel wird auch die Implementierung der Textklassifizierung mithilfe von CNN vorgestellt.

Textklassifizierung mit Convolution (CNN) und Spatial Pyramid Pooling (SPP-net)

[PYTHON] [Textklassifizierung] Ich habe versucht, Faltungsneurale Netze für die Satzklassifizierung mit Chainer zu implementieren