[PYTHON] Tech Circle ML # 8 Chainer mit wiederkehrendem neuronalen Sprachmodell

Wiederkehrendes Sprachmodell für neuronale Netze

Vorbereitungen http://qiita.com/GushiSnow/items/9ab8761082e29002f735

Github mit praktischem Code https://github.com/SnowMasaya/Chainer-with-Neural-Networks-Language-model-Hands-on.git

Überprüfen des Betriebs der Anwendung

Virtuelle Umgebung aktivieren

Mac/Linux

source my_env/bin/activate

pyenv install 3.4.1
pyenv rehash
pyenv local 3.4.1

Funktionsprüfung Gehen Sie direkt darunter wie folgt vor:

ipython notebook

Das Chainer-Notizbuch wird jetzt geöffnet.

Erleben Sie den Prozess der Erstellung eines wiederkehrenden neuronalen Sprachmodells

Öffnen Sie das iPython-Notizbuch. Hier sind die Schritte zum Erstellen eines wiederkehrenden neuronalen Sprachmodells in der angegebenen Reihenfolge. Da der Code im Satz tatsächlich mit dem iPython-Notizbuch ausgeführt werden kann, erklären wir ihn und führen ihn in der Reihenfolge von oben aus (Klicken Sie hier für eine detaillierte Verwendung) ( http://qiita.com/icoxfog417/items/175f69d06f4e590face9 )Bitte beziehen Sie sich auf).

Screen Shot 2015-09-15 at 7.30.33.jpg

Schauen Sie sich das Ipython-Notizbuch von hier bis zum Codierungsteil an.

Wiederkehrende Einstellung des neuronalen Sprachmodells (Codierungsteil)! !! !! !!

Das Modell ist in einer anderen Klasse definiert. Sie können das Modell in diesem Teil frei ändern. Der Zweck dieses Teils ist es, Ihnen zu helfen, die einzigartigen Eigenschaften des wiederkehrenden neuronalen Sprachmodells zu verstehen. -F.EmbedID führt den Prozess der Konvertierung von Wörterbuchdaten in Daten für die Anzahl der Eingabeeinheiten durch (Konvertierung in den latenten Vektorraum).

http://olanleed.hatenablog.com/entry/2013/12/03/010945

・ C1, h1 = F.lstm (Zustand ['c1'], h1_in) ist ein Gerät, mit dem wiederkehrende neuronale Netze mit einem guten Gefühl lernen können, ohne dass ein magisches Gerät namens lstm zu Gedächtnisstörungen und zum Verschwinden des Gradienten führt. .. Wenn Sie mehr wissen möchten, sehen Sie bitte unten.

http://www.slideshare.net/nishio/long-shortterm-memory

#-------------Explain2 in the Qiita-------------
class CharRNN(FunctionSet):

    """
Dies ist der Teil, der das neuronale Netzwerk definiert.
Der von oben eingegebene Wörterbuchvektorraum wird in die Anzahl der Einheiten der verborgenen Ebene konvertiert, und dann wird die verborgene Ebene eingegeben.
Einstellen der Leistung und der verborgenen Ebene.
Die gleiche Verarbeitung wird auf den beiden Ebenen durchgeführt, und die Ausgabeebene wird auf die Anzahl des Vokabulars und der Ausgabe korrigiert.
Der erste einzustellende Parameter ist-0.08 bis 0.Es wird zufällig zwischen 08 eingestellt.
    """
    
    def __init__(self, n_vocab, n_units):
        super(CharRNN, self).__init__(
            embed = F.EmbedID(n_vocab, n_units),
            l1_x = F.Linear(n_units, 4*n_units),
            l1_h = F.Linear(n_units, 4*n_units),
            l2_x = F.Linear(n_units, 4*n_units),
            l2_h = F.Linear(n_units, 4*n_units),
            l3   = F.Linear(n_units, n_vocab),
        )
        for param in self.parameters:
            param[:] = np.random.uniform(-0.08, 0.08, param.shape)

    """
Eine Beschreibung der Vorwärtsausbreitung.
Die Vorwärtsausbreitungseingabe wird in Variable definiert und die Eingabe und Antwort werden übergeben.
Verwenden Sie die Einbettung, die die Eingabeebene zuvor definiert hat.
Für die Eingabe der verborgenen Ebene wurde l1 zuvor definiert_Übergeben Sie mit x Dropout und den Status der verborgenen Ebene als Argumente
ist.
Versteckte Schicht in lstm Erster Schichtzustand und h1_Pass in.
Schreiben Sie die zweite Ebene auf die gleiche Weise und definieren Sie die Ausgabeebene, ohne den Status zu übergeben.
Jeder Status wird zur Verwendung in nachfolgenden Eingaben beibehalten.
Es vergleicht das Ausgabeetikett mit dem Antwortetikett und gibt den Verlust und den Status zurück.
    """

    def forward_one_step(self, x_data, y_data, state, train=True, dropout_ratio=0.5):
        x = Variable(x_data, volatile=not train)
        t = Variable(y_data, volatile=not train)

        h0      = self.embed(x)
        h1_in   = self.l1_x(F.dropout(h0, ratio=dropout_ratio, train=train)) + self.l1_h(state['h1'])
        c1, h1  = F.lstm(state['c1'], h1_in)
        h2_in   = self.l2_x(F.dropout(h1, ratio=dropout_ratio, train=train)) + self.l2_h(state['h2'])
        c2, h2  = F.lstm(state['c2'], h2_in)
        y       = self.l3(F.dropout(h2, ratio=dropout_ratio, train=train))
        state   = {'c1': c1, 'h1': h1, 'c2': c2, 'h2': h2}

        return state, F.softmax_cross_entropy(y, t)

    """
Die Beschreibung des Aussetzers wird entfernt und als Vorhersagemethode beschrieben.
Es gibt ein Argument namens Zug in Dropout, und es funktioniert nicht, wenn das Argument Zug auf false gesetzt ist
Zum Zeitpunkt der Vorhersage können Sie das Lernen und die Vorhersage ändern, indem Sie das übergebene Argument ändern. Diesmal ist dies jedoch ausdrücklich bekannt
Ich habe es separat wie folgt geschrieben.
    """

    def predict(self, x_data, state):
        x = Variable(x_data, volatile=True)

        h0      = self.embed(x)
        h1_in   = self.l1_x(h0) + self.l1_h(state['h1'])
        c1, h1  = F.lstm(state['c1'], h1_in)
        h2_in   = self.l2_x(h1) + self.l2_h(state['h2'])
        c2, h2  = F.lstm(state['c2'], h2_in)
        y       = self.l3(h2)
        state   = {'c1': c1, 'h1': h1, 'c2': c2, 'h2': h2}

        return state, F.softmax(y)
    
"""
Es ist die Initialisierung des Staates.
"""

def make_initial_state(n_units, batchsize=100, train=True):
    return {name: Variable(np.zeros((batchsize, n_units), dtype=np.float32),
            volatile=not train)
            for name in ('c1', 'h1', 'c2', 'h2')}
#-------------Explain2 in the Qiita-------------

Sprachvorhersage


Handson # 2 Erklärung

In Bezug auf die Erfassung von Zeichenkettendaten zur Vorhersage werden normalerweise die Trainingsdaten und die Testdaten getrennt, aber dieses Mal wollte ich, dass der Effekt praktisch realisiert wird, also habe ich die Trainingsdaten und die Testdaten gleich gemacht. Durch die Vorhersage werden Modelländerungen und Zeichenfolgenvorhersagen erstellt.

-Ändern Sie das Modell. -Vorgeben Sie die Zeichenfolge.

Um das vorhergesagte Modell zu ändern, ändern Sie den folgenden Code im iPython-Notizbuch. Da sich das erstellte Modell im Lebenslaufordner befindet Es gibt nicht viele, aber bitte überprüfen Sie es.

# load model
#-------------Explain5 in the Qiita-------------
model = pickle.load(open("cv/charrnn_epoch_x.chainermodel", 'rb'))
#-------------Explain5 in the Qiita-------------

#-------------Explain7 in the Qiita-------------
    state, prob = model.predict(np.array([index], dtype=np.int32), state)
    #index = np.argmax(prob.data)
    index = np.random.choice(prob.data.argsort()[0,-sampling_range:][::-1], 1)[0]
#-------------Explain7 in the Qiita-------------

Machen Sie Ihr Modell intelligenter und prognostizieren Sie

In diesem Hands On habe ich nur für eine begrenzte Zeit trainiert, sodass ich nur ein Modell mit schrecklicher Genauigkeit erstellen kann. Passen wir also die Parameter an und erstellen sie mithilfe des Modells neu. Parameter zum Einstellen

#-------------Explain7 in the Qiita-------------
n_epochs    = 30
n_units     = 625
batchsize   = 100
bprop_len   = 10
grad_clip   = 0.5
#-------------Explain7 in the Qiita-------------

Rolle jedes Parameters n_epochs repräsentiert die Anzahl der Lernvorgänge. Wenn das Modell kompliziert ist, konvergiert es nur, wenn die Anzahl der Schulungen erhöht wird. Wenn das Modell also kompliziert ist, muss eine große Anzahl festgelegt werden.

n_units ist die Anzahl der ausgeblendeten Ebenen. Je höher diese Zahl, desto komplexer ist das Modell. Wenn diese Anzahl erhöht wird, konvergiert das Lernen nicht, es sei denn, die Anzahl der Lernvorgänge wird erhöht. Insbesondere bei einem Sprachmodell ist es besser, es entsprechend der Anzahl der Vokabeln zu ändern. Wenn die Anzahl der Einheiten größer als die Anzahl der Vokabeln ist, bedeutet dies, dass die Zuordnung zum latenten Raum nicht möglich ist, was zu einer bedeutungslosen Verarbeitung führt.

Stapelgröße ist die Anzahl der Daten, die gleichzeitig gelernt werden müssen. Dies hängt von der Größe der Daten ab. Dieser Punkt wird oft empirisch angepasst, aber im Grunde genommen wird die Lerngenauigkeit verbessert, wenn er erhöht wird, aber die Lerngeschwindigkeit wird verringert, und wenn er verringert wird, wird die Lerngenauigkeit verringert, aber die Lerngeschwindigkeit wird erhöht.

bprop_len ist ein Parameter, der dem wiederkehrenden neuronalen Netz eigen ist und angibt, wie viele vergangene Zeichen beibehalten werden. Dies ist ein Parameter, der sich je nach zu lösendem Problem ändert. Stellen Sie daher eine große Zahl ein, wenn Sie einen langen Satz vorhersagen möchten, und eine kurze Zahl, wenn der Satz nicht relativ lang ist.

optimizer.clip_grads (grad_clip) legt eine Obergrenze für die Größe des Verlaufs (Gewichtsaktualisierungsbreite) fest, um zu verhindern, dass die Gewichte explodieren. Ein großer Wert ermöglicht das Lernen und ein kleiner Wert unterdrückt das Lernen.

Weitere Informationen zur Optimierung von Hyperparametern finden Sie unten

http://colinraffel.com/wiki/neural_network_hyperparameters

Handson Advance

Die Sprachverarbeitung nimmt viel Zeit in Anspruch, daher empfehle ich GPU-Einstellungen. Dies bedeutet jedoch nicht, dass es unbedingt verwendet werden sollte, und es funktioniert in den folgenden Einstellungen effektiv. Wenn Sie die Details des Mechanismus erfahren möchten, lesen Sie bitte unten. http://www.kumikomi.net/archives/2008/06/12gpu1.php?page=1

Für diejenigen, die es mit hoher Geschwindigkeit versuchen möchten

http://sla.hatenablog.com/entry/chainer_on_ec2

github (für diese GPU) Verwenden Sie eine GPU-Instanz (basierend auf Amazon Linux) mit einer von NVIDIA veröffentlichten CUDA-Umgebung

https://github.com/SnowMasaya/Chainer-with-Neural-Networks-Language-model-Hands-on-Advance.git

GPU-Treibereinstellungen

Die GPU-Einstellungen in AWS wurden unter Bezugnahme auf die folgende Site vorgenommen.

http://tleyden.github.io/blog/2014/10/25/cuda-6-dot-5-on-aws-gpu-instance-running-ubuntu-14-dot-04/

apt-get update && apt-get install build-essential

Holen Sie sich das Cuda-Installationsprogramm

wget http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda_6.5.14_linux_64.run

Holen Sie sich nur Cuda Installer

chmod +x cuda_6.5.14_linux_64.run
mkdir nvidia_installers
./cuda_6.5.14_linux_64.run -extract=`pwd`/nvidia_installers

Holen Sie sich einen Bildextrakt

sudo apt-get install linux-image-extra-virtual

Starten Sie neu

reboot

Erstelle Datei

vi /etc/modprobe.d/blacklist-nouveau.conf

Setze Nouveau und lbm-Nouveau nicht ein

blacklist nouveau
blacklist lbm-nouveau
options nouveau modeset=0
alias nouveau off
alias lbm-nouveau off

Stellen Sie Kernel Nouveau nicht ein

 echo options nouveau modeset=0 | sudo tee -a /etc/modprobe.d/nouveau-kms.conf

Nehmen Sie Einstellungen vor, um das Dateisystem zu konfigurieren, indem Sie es beim Starten des Kernels vorab in den Speicher erweitern und dann neu starten

update-initramfs -u
reboot

Holen Sie sich die Quelle des Kernels

apt-get install linux-source
apt-get install linux-headers-3.13.0-37-generic

Installieren Sie den NVIDIA-Treiber

cd nvidia_installers
./NVIDIA-Linux-x86_64-340.29.run

Überprüfen Sie mit dem folgenden Befehl, ob der Treiber installiert ist.

nvidia-smi
Wed Aug  5 07:48:36 2015
+------------------------------------------------------+
| NVIDIA-SMI 340.29     Driver Version: 340.29         |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GRID K520           Off  | 0000:00:03.0     Off |                  N/A |
| N/A   54C    P0    80W / 125W |    391MiB /  4095MiB |     99%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Compute processes:                                               GPU Memory |
|  GPU       PID  Process name                                     Usage      |
|=============================================================================|
|    0      8013  python                                               378MiB |
+-----------------------------------------------------------------------------+

Die der obigen GPU zugewiesene Nummer ist die GPU-ID. Dies wird später verwendet, wenn Chainer ausgeführt wird.

Fehler beim Laden von gemeinsam genutzten Bibliotheken: libcurand.so.5.5: Datei für gemeinsam genutzte Objekte kann nicht geöffnet werden: Keine solche Datei oder kein solches Verzeichnis

http://linuxtoolkit.blogspot.jp/2013/09/error-while-loading-shared-libraries.html

Übergeben Sie auch den Pfad

export PATH=$PATH:/usr/local/cuda-6.5/bin/

Python-Einstellungen

Ich habe Python3 eingerichtet.

Führen Sie den folgenden Befehl aus, um die erforderlichen Elemente im Voraus zu installieren


apt-get update
apt-get install gcc gcc++ kmod perl python-dev
sudo reboot

Installationsverfahren für Pip https://pip.pypa.io/en/stable/installing.html

Pyenv-Installationsverfahren https://github.com/yyuu/pyenv


pip install virtualenv

pyenv install 3.4

virtualenv my_env -p = ~/.pyenv/versions/3.4.0/bin/python3.4

Ich habe request.txt gesetzt.

numpy
scikit-learn
Mako
six
chainer
scikit-cuda

Installieren Sie die erforderlichen Bibliotheken

pip install -r requirement.txt

Laden Sie "Install-Header" von den folgenden herunter.

https://android.googlesource.com/toolchain/python/+/47a24ea6662f20c8e165d541ab6facdf009bfee4/Python-2.7.5/Lib/distutils/command/install_headers.py

Installieren Sie PyCuda

wget https://pypi.python.org/packages/source/p/pycuda/pycuda-2015.1.2.tar.gz
tar zxvf pycuda-2015.1.2.tar.gz
cd pycuda-2015.1.2
./configure.py
make
make install

Handson Advance2

Führen Sie ipython notebook auf dem Server aus und überprüfen Sie den Vorgang (unter AWS).

https://thomassileo.name/blog/2012/11/19/setup-a-remote-ipython-notebook-server-with-numpyscipymaltplotlibpandas-in-a-virtualenv-on-ubuntu-server/

Festlegen der Dateierstellung

ipython profile create myserver

Ändern Sie die Einstellungsdatei

vim /home/ec2-user/.ipython/profile_myserver/ipython_config.py

Zeile hinzufügen

c = get_config()

c.IPKernelApp.pylab = 'inline'
c.NotebookApp.ip = '*'
c.NotebookApp.open_browser = False
c.NotebookApp.password = u'sha1:yourhashedpassword'
c.NotebookApp.port = 9999

Bleib in Cudas Pfad

export PATH=$PATH:/usr/local/cuda-6.5/bin/
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-6.5/lib64/

Öffnen Sie den Port, den Sie öffnen möchten, über die AWS-Sicherheitsgruppe

1: Wählen Sie eine Sicherheitsgruppe aus 2: Regel durch Bearbeiten hinzufügen 3: Typ: Benutzerdefinierte TCP-Regel 4: Protokoll: TCP 5: Port: 9999 6: Quelle kann überall eingestellt werden

Lauf Da dies im normalen Verfahren nicht berücksichtigt wird, spiegeln Sie die Profildatei direkt wider.

sudo ipython notebook --config=/home/ec2-user/.ipython/profile_myserver/ipython_config.py --no-browser

Für diejenigen mit Ambitionen, die noch studieren wollen

"Statistische Sprachmodelle basierend auf neuronalen Netzen" auf der folgenden Website ist sehr gut organisiert und leicht zu verstehen. Obwohl es auf Englisch ist.

http://rnnlm.org/

Liste der Referenzseiten

Erklärung der Sprachmodellabdeckung, Ratlosigkeit

http://marujirou.hatenablog.com/entry/2014/08/22/235215

Führen Sie das Deep Learning Framework Chainer auf der EC2-GPU-Instanz g2.2xlarge aus

http://ukonlly.hatenablog.jp/entry/2015/07/04/210149

Drop Out

http://olanleed.hatenablog.com/entry/2013/12/03/010945

Learning to forget continual prediction with lstm

http://www.slideshare.net/FujimotoKeisuke/learning-to-forget-continual-prediction-with-lstm

Zaremba, Wojciech, Ilya Sutskever, and Oriol Vinyals. "Recurrent neural network regularization." arXiv preprint arXiv:1409.2329 (2014).

Google Mikolov

http://www.rnnlm.org/

Sprachmodell (LM) unter Verwendung eines neuronalen Netzwerks (NN), dh eine Art neuronales Netzwerk-Sprachmodell (NNLM), wiederkehrendes neuronales Netzwerk-Sprachmodell (RNNLM) unter Verwendung eines wiederkehrenden neuronalen Netzwerks (RNN)

http://kiyukuta.github.io/2013/12/09/mlac2013_day9_recurrent_neural_network_language_model.html

Long Short-term Memory

http://www.slideshare.net/nishio/long-shortterm-memory

Während wir Chainers ptb-Beispiel erklären, lernen wir Ihre eigenen Sätze gründlich und generieren automatisch meine satzartigen Sätze

http://d.hatena.ne.jp/shi3z/20150714/1436832305

RNNLM

http://www.slideshare.net/uchumik/rnnln

Spurth Estimation Übersicht: Modelle / Theorien / Anwendungen

http://www.is.titech.ac.jp/~s-taiji/tmp/sparse_tutorial_2014.pdf

Optimierungsmethode in regulierter Lernmethode

http://imi.kyushu-u.ac.jp/~waki/ws2013/slide/suzuki.pdf

Referenz zur Erstellung eines wiederkehrenden neuronalen Sprachmodells https://github.com/yusuketomoto/chainer-char-rnn

Verarbeitung der natürlichen Sprache des neuronalen Netzes http://www.orsj.or.jp/archive2/or60-4/or60_4_205.pdf

Erstellung von Sprachmodellen http://www.slideshare.net/uchumik/rnnln

Programmiergruppe für die Verarbeitung natürlicher Sprache n-Gramm-Sprachmodell http://www.phontron.com/slides/nlp-programming-ja-02-bigramlm.pdf

Einführung in die statistische Semantik ~ Von der Verteilungshypothese zu word2vec ~ http://www.slideshare.net/unnonouno/20140206-statistical-semantics

linux source code https://github.com/torvalds/linux

  1. Warum GPU-Computing Aufmerksamkeit erregt - Keio Gijuku http://www.yasuoka.mech.keio.ac.jp/gpu/gpu_0.php

Praxis des GPU-Computing mit CUDA-Technologie (Teil 1) - Anwendung der im Grafikbereich verfeinerten Parallelverarbeitungstechnologie auf die allgemeine numerische Berechnung http://www.kumikomi.net/archives/2008/06/12gpu1.php?page=1

GPGPU https://ja.wikipedia.org/wiki/GPGPU#.E7.89.B9.E5.BE.B4.E3.81.A8.E8.AA.B2.E9.A1.8C

Theorie der Verarbeitung natürlicher Sprache I. http://www.jaist.ac.jp/~kshirai/lec/i223/02.pdf

STATISTICAL LANGUAGE MODELS BASED ON NEURAL NETWORKS http://www.rnnlm.org/

Neural Network Hyperparameters http://colinraffel.com/wiki/neural_network_hyperparameters

Random Search for Hyper-Parameter Optimization http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf

Recommended Posts

Tech Circle ML # 8 Chainer mit wiederkehrendem neuronalen Sprachmodell
Neuronales Netz beginnend mit Chainer
4. Kreisparameter mit einem neuronalen Netzwerk!
Einfaches Klassifizierungsmodell mit neuronalem Netz
Seq2Seq (2) ~ Achtung Model Edition ~ mit Chainer
Laden Sie das Kaffeemodell mit Chainer und klassifizieren Sie die Bilder
Bilderkennung mit Caffe Model Chainer Yo!