[PYTHON] Chainer Tech Circle ML # 8 avec modèle récurrent de langage neuronal
Modèle de langage de réseau neuronal récurrent
Préparation préalable http://qiita.com/GushiSnow/items/9ab8761082e29002f735
Github avec code pratique https://github.com/SnowMasaya/Chainer-with-Neural-Networks-Language-model-Hands-on.git
Vérification du fonctionnement de l'application
Activer l'environnement virtuel
Mac/Linux
source my_env/bin/activate
pyenv install 3.4.1
pyenv rehash
pyenv local 3.4.1
Contrôle de fonctionnement Directement ci-dessous, procédez comme suit:
ipython notebook
Le bloc-notes Chainer va maintenant s'ouvrir.
Découvrez le processus de création d'un modèle de langage neuronal récurrent
Ouvrez le bloc-notes iPython. Voici les étapes pour créer un modèle de langage neuronal récurrent dans l'ordre. Étant donné que le code de la phrase peut réellement être exécuté avec le notebook iPython, expliquons-le et exécutons-le dans l'ordre du haut (Cliquez ici pour une utilisation détaillée) ( http://qiita.com/icoxfog417/items/175f69d06f4e590face9 )Prière de se référer à).
Regardez le cahier ipython d'ici à la partie de codage.
Réglage du modèle de langage neuronal récurrent (partie de codage)! !! !! !!
Le modèle est défini dans une autre classe.
Vous pouvez modifier librement le modèle dans cette partie.
Le but de cette partie est de vous aider à comprendre les caractéristiques uniques du modèle de langage neuronal récurrent.
-F.EmbedID effectue le processus de conversion des données du dictionnaire en données pour le nombre d'unités d'entrée (conversion en espace vectoriel latent).
-La raison pour laquelle la sortie est quadruplée est que la couche d'entrée, la couche de restriction d'entrée, la couche de restriction de sortie et la couche d'oubli sont utilisées pour l'entrée dans LSTM.
・ H1_in = self.l1_x (F.dropout (h0, ratio = dropout_ratio, train = train)) + self.l1_h (state ['h1']) est une unité avec combien d'abandons tout en conservant les informations passées Indique s'il faut gratter.
Voir ci-dessous pour l'abandon.
http://olanleed.hatenablog.com/entry/2013/12/03/010945
・ C1, h1 = F.lstm (state ['c1'], h1_in) est un appareil pour le réseau neuronal récurrent pour apprendre avec une bonne sensation sans provoquer de défaillance de la mémoire et de disparition de gradient par un appareil magique appelé lstm. .. Si vous voulez en savoir plus, veuillez voir ci-dessous.
http://www.slideshare.net/nishio/long-shortterm-memory
-Etat de retour, F.softmax_cross_entropy (y, t) est l'endroit où la fonction de perte est mise à jour en comparant le caractère prédit avec le caractère réel. La raison de l'utilisation de la fonction softmax est que la sortie peut être déterminée en considérant toutes les entrées de la couche immédiatement avant la couche de sortie, de sorte que la fonction softmax est généralement utilisée pour le calcul de la couche de sortie.
#-------------Explain2 in the Qiita-------------
class CharRNN(FunctionSet):
"""
C'est la partie qui définit le réseau neuronal.
L'espace vectoriel du dictionnaire entré dans l'ordre à partir du haut est converti en nombre d'unités de calque masquées, puis le calque masqué est entré.
Réglage de la puissance et de la couche cachée.
Le même traitement est effectué sur les deux couches, et la couche de sortie corrige le nombre de vocabulaire et le produit.
Le premier paramètre à définir est-0.08 à 0.Il est défini aléatoirement entre 08.
"""
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)
"""
Une description de la propagation vers l'avant.
L'entrée de propagation directe est définie dans Variable et l'entrée et la réponse sont transmises.
Utilisez l'intégration qui a défini la couche d'entrée plus tôt.
Pour l'entrée du calque caché, l1 défini précédemment_Utilisation de x, passer le décrochage et l'état de couche masqué comme arguments
est.
Couche cachée dans l'état de première couche lstm et h1_Passer.
Ecrivez la deuxième couche de la même manière et définissez la couche de sortie sans passer l'état.
Chaque état est conservé pour une utilisation dans les entrées suivantes.
Il compare l'étiquette de sortie avec l'étiquette de réponse et renvoie la perte et l'état.
"""
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)
"""
La description de l'abandon est supprimée et elle est décrite comme une méthode de prédiction.
Il existe un argument appelé train in dropout, et il ne fonctionnera pas si l'argument de train est défini sur false
Ainsi, au moment de la prédiction, vous pouvez changer l'apprentissage et la prédiction en modifiant l'argument passé, mais cette fois, il est explicitement connu
Je l'ai écrit séparément comme suit.
"""
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)
"""
C'est l'initialisation de l'état.
"""
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-------------
Prédiction de la langue
Explication du Handson n ° 2
En ce qui concerne l'acquisition de données de chaîne de caractères pour la prédiction, normalement les données d'entraînement et les données de test sont séparées, mais cette fois, je voulais que l'effet soit réalisé de manière pratique, j'ai donc rendu les données d'entraînement et les données de test identiques. La prédiction effectue des changements de modèle et crée des prédictions de chaîne.
-Changer le modèle. -Prédire la chaîne de caractères.
Pour modifier le modèle prévu, modifiez le code ci-dessous dans le bloc-notes iPython. Puisque le modèle créé est dans le dossier cv Il n'y en a pas beaucoup, mais vérifiez-le.
# load model
#-------------Explain5 in the Qiita-------------
model = pickle.load(open("cv/charrnn_epoch_x.chainermodel", 'rb'))
#-------------Explain5 in the Qiita-------------
-La probabilité et l'état prédits par state, prob = model.predict (np.array ([index], dtype = np.int32), state) sont acquis. L'état est également acquis pour être utilisé dans la prochaine prédiction.
・ ʻIndex = np.argmax (cuda.to_cpu (prob.data)) a la probabilité la plus élevée parmi eux parce que la probabilité de poids de chaque mot peut être obtenue dans la partie cuda.to_cpu (prob.data) `. Est-ce le caractère attendu, donc j'essaye de renvoyer l'index pour ce caractère.
・ ʻIndex = np.random.choice (prob.data.argsort () [0, -sampling_range:] [:: -1], 1) [0] ʻest la probabilité que des caractères similaires à récurrents soient affichés. Est élevé, donc le processus de sortie aléatoire à partir des 5 meilleurs candidats est également inclus. Puisque c'est la partie où vous voulez voir qu'une grande variété de sorties est sortie, vous devez à l'origine sélectionner la valeur maximale.
#-------------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-------------
Rendez votre modèle plus intelligent et prévoyez
Dans ce Hands On, je ne me suis entraîné que pour un temps limité, donc je ne peux créer qu'un modèle avec une précision terrible. Alors ajustons les paramètres et recréons-les en utilisant le modèle. Paramètres à régler
#-------------Explain7 in the Qiita-------------
n_epochs = 30
n_units = 625
batchsize = 100
bprop_len = 10
grad_clip = 0.5
#-------------Explain7 in the Qiita-------------
Rôle de chaque paramètre n_epochs représente le nombre d'apprentissage. Si le modèle est compliqué, il ne convergera que si le nombre de formations est augmenté, donc si le modèle est compliqué, il est nécessaire de définir un grand nombre.
n_units est le nombre de couches cachées. Plus ce nombre est élevé, plus le modèle est complexe. Si ce nombre est augmenté, l'apprentissage ne convergera pas à moins que le nombre d'apprentissage ne soit augmenté. Surtout dans le cas d'un modèle de langage, il vaut mieux le changer en fonction du nombre de vocabulaire. Si le nombre d'unités est supérieur au nombre de vocabulaire, cela signifie que le mappage vers l'espace latent n'est pas possible, ce qui entraîne un traitement dénué de sens.
batchsize est le nombre de données à apprendre à la fois. Cela dépend de la taille des données. Ce point est souvent ajusté empiriquement, mais fondamentalement, si vous l'augmentez, la vitesse d'apprentissage diminuera au détriment de l'amélioration de la précision d'apprentissage, et si vous la diminuez, la vitesse d'apprentissage augmentera au prix d'une diminution de la précision d'apprentissage.
bprop_len est un paramètre propre au réseau neuronal récurrent et indique combien de caractères passés sont conservés. C'est un paramètre qui change en fonction du problème à résoudre, alors définissez un grand nombre si vous voulez prédire une phrase longue, et définissez un nombre court si la phrase n'est pas relativement longue.
optimizer.clip_grads (grad_clip) met une limite supérieure sur la magnitude du gradient (largeur de mise à jour du poids) pour empêcher les poids d'exploser. Une grande valeur permet l'apprentissage et une petite valeur supprime l'apprentissage.
Pour en savoir plus sur l'optimisation des hyperparamètres, voir ci-dessous
http://colinraffel.com/wiki/neural_network_hyperparameters
Handson Advance
Le traitement du langage prend beaucoup de temps, je recommande donc les paramètres GPU. Cependant, cela ne signifie pas qu'il doit être utilisé sans condition, et il fonctionne efficacement dans les paramètres suivants. Si vous souhaitez connaître les détails du mécanisme, veuillez voir ci-dessous. http://www.kumikomi.net/archives/2008/06/12gpu1.php?page=1
-
Bon à Calcul matriciel Accès séquentiel à la mémoire et fort dans les calculs sans branchement conditionnel (traitement à haute densité de calcul).
-
Je ne suis pas bon en Recherche de bisection Accès aléatoire à la mémoire et à de nombreuses branches conditionnelles.
Pour ceux qui veulent essayer à grande vitesse
http://sla.hatenablog.com/entry/chainer_on_ec2
github (pour ce GPU) Utiliser une instance de GPU (basée sur Amazon Linux) avec l'environnement CUDA publié par NVIDIA
https://github.com/SnowMasaya/Chainer-with-Neural-Networks-Language-model-Hands-on-Advance.git
Paramètres du pilote GPU
Les paramètres GPU sur AWS ont été définis en référence au site suivant.
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
Obtenez le programme d'installation de Cuda
wget http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda_6.5.14_linux_64.run
Obtenez uniquement le programme d'installation de Cuda
chmod +x cuda_6.5.14_linux_64.run
mkdir nvidia_installers
./cuda_6.5.14_linux_64.run -extract=`pwd`/nvidia_installers
Obtenir un extrait d'image
sudo apt-get install linux-image-extra-virtual
Redémarrer
reboot
Créer un fichier
vi /etc/modprobe.d/blacklist-nouveau.conf
définir nouveau et lbm-nouveau pour ne pas démarrer
blacklist nouveau
blacklist lbm-nouveau
options nouveau modeset=0
alias nouveau off
alias lbm-nouveau off
Ne pas démarrer Kernel Nouveau
echo options nouveau modeset=0 | sudo tee -a /etc/modprobe.d/nouveau-kms.conf
Définissez les paramètres pour configurer le système de fichiers en développant la mémoire à l'avance lorsque le noyau démarre, puis redémarrez
update-initramfs -u
reboot
Obtenez la source du noyau
apt-get install linux-source
apt-get install linux-headers-3.13.0-37-generic
Installez le pilote NVIDIA
cd nvidia_installers
./NVIDIA-Linux-x86_64-340.29.run
Vérifiez si le pilote est installé avec la commande suivante.
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 |
+-----------------------------------------------------------------------------+
Le numéro attribué au GPU ci-dessus est l'ID du GPU. Cela sera utilisé plus tard lors de l'exécution de Chainer.
ʻErreur lors du chargement des bibliothèques partagées: libcurand.so.5.5: impossible d'ouvrir le fichier objet partagé: aucun fichier ou répertoire de ce type `
http://linuxtoolkit.blogspot.jp/2013/09/error-while-loading-shared-libraries.html
Passez également le CHEMIN
export PATH=$PATH:/usr/local/cuda-6.5/bin/
Paramètres Python
J'ai mis en place Python3.
Exécutez la commande suivante pour installer les éléments nécessaires à l'avance
apt-get update
apt-get install gcc gcc++ kmod perl python-dev
sudo reboot
procédure d'installation de pip https://pip.pypa.io/en/stable/installing.html
Procédure d'installation de Pyenv https://github.com/yyuu/pyenv
pip install virtualenv
pyenv install 3.4
virtualenv my_env -p = ~/.pyenv/versions/3.4.0/bin/python3.4
J'ai défini exigence.txt.
numpy
scikit-learn
Mako
six
chainer
scikit-cuda
Installez les bibliothèques requises
pip install -r requirement.txt
Téléchargez "install-headers" à partir de ce qui suit.
https://android.googlesource.com/toolchain/python/+/47a24ea6662f20c8e165d541ab6facdf009bfee4/Python-2.7.5/Lib/distutils/command/install_headers.py
Installez 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
Exécutez ipython notebook sur le serveur et vérifiez l'opération (sur AWS)
https://thomassileo.name/blog/2012/11/19/setup-a-remote-ipython-notebook-server-with-numpyscipymaltplotlibpandas-in-a-virtualenv-on-ubuntu-server/
Création de fichier de configuration
ipython profile create myserver
Modifier le fichier de paramètres
vim /home/ec2-user/.ipython/profile_myserver/ipython_config.py
Ajouter une ligne
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
Restez dans le PATH de Cuda
export PATH=$PATH:/usr/local/cuda-6.5/bin/
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-6.5/lib64/
Ouvrez le port que vous souhaitez ouvrir à partir du groupe de sécurité AWS
1: Sélectionnez un groupe de sécurité 2: Ajouter une règle en modifiant 3: Type: règle TCP personnalisée 4: protocole: TCP 5: Port: 9999 6: la source peut être définie n'importe où
Courir Puisqu'il n'est pas reflété dans la procédure normale, reflétez directement le fichier de profilage.
sudo ipython notebook --config=/home/ec2-user/.ipython/profile_myserver/ipython_config.py --no-browser
Pour ceux qui ont des aspirations et qui veulent encore étudier
Les "Modèles de langage statistique basés sur des réseaux de neurones" sur le site suivant sont très organisés et faciles à comprendre. Bien que ce soit en anglais.
http://rnnlm.org/
Liste des sites de référence
Explication de la couverture du modèle de langage, perplexité
http://marujirou.hatenablog.com/entry/2014/08/22/235215
Exécutez le framework d'apprentissage en profondeur Chainer sur l'instance GPU EC2 instance g2.2xlarge
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/
Modèle de langage (LM) utilisant le réseau neuronal (NN), c'est-à-dire un type de modèle de langage de réseau neuronal (NNLM), modèle de langage de réseau neuronal récurrent (RNNLM) utilisant le réseau neuronal récurrent (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
Tout en expliquant l'exemple ptb de Chainer, apprenons profondément vos propres phrases et générons automatiquement mes phrases semblables à des phrases
http://d.hatena.ne.jp/shi3z/20150714/1436832305
RNNLM
http://www.slideshare.net/uchumik/rnnln
Présentation de Spurth Estimate: modèles / théories / applications
http://www.is.titech.ac.jp/~s-taiji/tmp/sparse_tutorial_2014.pdf
Méthode d'optimisation en méthode d'apprentissage régularisée
http://imi.kyushu-u.ac.jp/~waki/ws2013/slide/suzuki.pdf
Référence de création de modèle de langage neuronal récurrent https://github.com/yusuketomoto/chainer-char-rnn
Traitement du langage naturel du réseau neuronal http://www.orsj.or.jp/archive2/or60-4/or60_4_205.pdf
Création de modèle de langage http://www.slideshare.net/uchumik/rnnln
Modèle de langage N-Gram du groupe d'étude sur la programmation du traitement du langage naturel http://www.phontron.com/slides/nlp-programming-ja-02-bigramlm.pdf
Introduction à la sémantique statistique ~ De l'hypothèse de distribution à word2vec ~ http://www.slideshare.net/unnonouno/20140206-statistical-semantics
linux source code https://github.com/torvalds/linux
- Pourquoi l'informatique GPU attire l'attention - Keio Gijuku http://www.yasuoka.mech.keio.ac.jp/gpu/gpu_0.php
Pratique du calcul GPU utilisant la technologie CUDA (Partie 1) - Application de la technologie de traitement parallèle affinée dans le domaine graphique au calcul numérique général 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
Théorie du traitement du langage naturel 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