char rnn chinese
1.0.0
Basé sur le code d'Andrej Karpathy https://github.com/karpathy/char-rnn et le papier de Samy Bengio http://arxiv.org/abs/1506.03099
Faire le code peut traiter les caractères anglais et chinois. Ceci est ma première touche de Lua, donc le processus de chaîne semble idiot, mais cela fonctionne bien.
J'ajoute également une option appelée «min_freq» car la taille du vocabulaire en chinois est très grande, ce qui rend le nombre de paramètres beaucoup. Donc, supprimer un caractère rare peut aider.
L'échantillonnage programmé de l'article de Samy Bengio pour la prédiction de séquence avec des réseaux de neurones récurrents dans NIPS15 propose une méthode simple mais de puissance pour impliquer RNN.
Dans mon expérience, je trouve que cela aide beaucoup à éviter le sur-ajustement et à rendre la perte de test plus profonde. J'utilise uniquement la désintégration linéaire.
Utilisez -use_ss pour activer ou désactiver l'échantillonnage planifié, la valeur par défaut est activée. -start_ss est l'omunt de démarrage des données réelles, je suggère d'utiliser 1 car notre modèle devrait apprendre des données sans bruit au tout début. -min_ss est également très important car trop de bruit nuira aux performances. Enfin, -decay_ss est le taux de décroissance linéaire.
J'ajoute un script pour convertir un fichier de modèle formé par GPU au modèle CPU. Vous pouvez l'essayer comme suit:
$ th convert.lua gpu_model cpu_modelUne démonstration Web est ajoutée pour que d'autres testent facilement le modèle, basé sur le sous / pub de redis. J'utilise Redis car je ne peux pas trouver un bon RPC ou un serveur Web Work bien intégré à Torch. Vous devez remarquer que la démo est asynchrone par Ajax. Pour configurer la démo sur Ubuntu: Installez Redis et démarrez-le
$ wget http://download.redis.io/releases/redis-3.0.3.tar.gz
$ tar xzf redis-3.0.3.tar.gz
$ cd redis-3.0.3
$ make
$ sudo make install
$ redis-server &Installez ensuite Flask et le plugin Redis:
$ sudo pip install flask
$ sudo pip install redis
$ luarocks install redis-luaMettez votre modèle de modèle dans en ligne_model, renommez-le en tant que «modèle.t7», le script de démarrage du backend et de la police:
$ nohup th web_backend.lua &
$ nohup python web_server.py & Veuillez suivre ceci pour configurer votre expérience.
Ce code implémente le réseau neuronal récurrent multicouche (RNN, LSTM et GRU) pour la formation / l'échantillonnage à partir de modèles de langage au niveau des caractéristiques. Le modèle apprend à prédire la probabilité du caractère suivant dans une séquence. En d'autres termes, l'entrée est un seul fichier texte et le modèle apprend à générer du texte comme celui-ci.
Le contexte de cette base de code est décrit en détail dans mon article de blog. La page du projet qui a quelques pointeurs vers certains ensembles de données.
Ce code était à l'origine basé sur la classe d'apprentissage automatique d'Oxford University Practical 6, qui est à son tour basé sur l'apprentissage de l'exécution du code de Wojciech Zaremba. Des morceaux de celui-ci ont également été développés en collaboration avec mon Labate Justin Johnson.
Ce code est écrit en Lua et nécessite une torche. De plus, vous devez installer les packages nngraph et optim à l'aide de Luarocks que vous pourrez faire après l'installation de la torche:
$ luarocks install nngraph
$ luarocks install optim Si vous souhaitez utiliser CUDA GPU Computing, vous devrez d'abord installer la boîte à outils CUDA, puis les packages cutorch et cunn :
$ luarocks install cutorch
$ luarocks install cunn Si vous souhaitez utiliser OpenCL GPU Computing, vous devrez d'abord installer les packages cltorch et clnn , puis utiliser l'option -opencl 1 pendant la formation:
$ luarocks install cltorch
$ luarocks install clnn Toutes les données d'entrée sont stockées dans les data/ répertoires. Vous remarquerez qu'il existe un exemple de jeu de données inclus dans le dépôt (dans data/tinyshakespeare ) qui se compose d'un sous-ensemble d'œuvres de Shakespeare. Je fournis quelques ensembles de données supplémentaires sur la page du projet.
Vos propres données : si vous souhaitez utiliser vos propres données, créez une seule input.txt de fichier.txt et placez-les dans un dossier dans data/ . Par exemple, data/some_folder/input.txt . La première fois que vous exécutez le script d'entraînement, il écrira deux autres fichiers de commodité dans data/some_folder .
Notez que si vos données sont trop petites (1 Mo est déjà considérée comme très petite), le RNN n'apprendra pas très efficacement. N'oubliez pas qu'il doit tout apprendre complètement à partir de zéro.
Inversement, si vos données sont importantes (plus de 2 Mo), n'hésitez pas à augmenter rnn_size et à former un modèle plus grand (voir les détails de la formation ci-dessous). Cela fonctionnera beaucoup mieux . Par exemple, avec 6 Mo, vous pouvez facilement monter à rnn_size 300 ou même plus. Le plus important qui s'adapte à mon GPU et que je me suis entraîné avec ce code est rnn_size 700 avec num_layers 3 (2 est par défaut).
Commencez à former le modèle à l'aide de train.lua , par exemple:
$ th train.lua -data_dir data/some_folder -gpuid -1
Le drapeau -data_dir est le plus important car il spécifie l'ensemble de données à utiliser. Notez que dans cet exemple, nous définissons également gpuid sur -1 qui indique au code de s'entraîner à l'aide de CPU, sinon il est par défaut GPU 0. Il existe de nombreux autres indicateurs pour diverses options. Consultez $ th train.lua -help pour des paramètres complets. Voici un autre exemple:
$ th train.lua -data_dir data/some_folder -rnn_size 512 -num_layers 2 -dropout 0.5
Pendant que le modèle est en formation, il rédigera périodiquement des fichiers de point de contrôle dans le dossier cv . La fréquence à laquelle ces points de contrôle sont écrits sont contrôlés avec le nombre d'itérations, comme spécifié avec l'option eval_val_every (par exemple si cela est 1, alors un point de contrôle est écrit chaque itération). Le nom de fichier de ces points de contrôle contient un numéro très important: la perte . Par exemple, un point de contrôle avec le nom de fichier lm_lstm_epoch0.95_2.0681.t7 indique qu'à ce stade, le modèle était sur l'époque 0.95 (c'est-à-dire qu'il a presque fait un laissez-passer complet sur les données de formation), et la perte de données de validation était de 2,0681. Ce nombre est très important car plus il est inférieur, mieux le point de contrôle fonctionne. Une fois que vous commencez à générer des données (discutées ci-dessous), vous voudrez utiliser le point de contrôle du modèle qui a la perte de validation la plus faible. Notez que ce n'est pas nécessairement le dernier point de contrôle à la fin de la formation (en raison d'une éventuelle sur-ajustement).
Les autres quantités importantes à connaître sont batch_size (appelez-le b), seq_length (appelez-le) et les paramètres train_frac et val_frac . La taille du lot spécifie le nombre de flux de données traités en parallèle en même temps. La longueur de séquence spécifie la longueur de chaque morceau, qui est également la limite à laquelle les gradients sont coupés. Par exemple, si seq_length est de 20, alors le signal de gradient ne rétablira jamais plus de 20 pas de temps, et le modèle pourrait ne pas trouver de dépendances plus longtemps que cette longueur en nombre de caractères. Au moment de l'exécution, votre fichier texte d'entrée a n caractères, ceux-ci se divisent d'abord en morceaux de taille BXS. Ces morceaux sont ensuite alloués à trois divisions: train / val / test en fonction des paramètres frac . Si vos données sont petites, il est possible qu'avec les paramètres par défaut, vous n'aurez que très peu de morceaux au total (par exemple 100). C'est mauvais: dans ces cas, vous voudrez peut-être diminuer la taille du lot ou la longueur de séquence.
Vous pouvez également les paramètres INIT à partir d'un point de contrôle précédemment enregistré à l'aide init_from .
Nous pouvons utiliser ces points de contrôle pour générer du texte (discuté ensuite).
Étant donné un fichier de point de contrôle (comme ceux écrits sur cv ), nous pouvons générer un nouveau texte. Par exemple:
$ th sample.lua cv/some_checkpoint.t7 -gpuid -1
Assurez-vous que si votre point de contrôle a été formé avec GPU, il est également échantillonné avec GPU, ou vice versa. Sinon, le code se plaindra (actuellement). Comme avec le script de train, voir $ th sample.lua -help pour les options complètes. Un important est (par exemple) -length 10000 qui générerait 10 000 caractères (par défaut = 2000).
Température . Un paramètre important que vous voudrez peut-être jouer avec beaucoup est -temperature , qui prend un nombre dans la plage [0, 1] (avis 0 non inclus), par défaut = 1. La température divise les probabilités de logarithme prédit avant le softmax, donc la température plus basse entraînera la facilité, mais aussi plus de prédictions ennuyeuses et conservatrices. Des températures plus élevées font que le modèle prend plus de chances et augmente la diversité des résultats, mais à un coût de plus d'erreurs.
Amorçage . Il est également possible d'amorcer le modèle avec un texte de départ en utilisant -primetext . Cela commence le RNN avec des personnages codés en dur pour le réchauffer avec un peu de contexte avant de commencer à générer du texte.
Bonne échantillonnage!
Si vous êtes quelque peu nouveau dans l'apprentissage automatique ou les réseaux de neurones, il peut prendre un peu d'expertise pour obtenir de bons modèles. La quantité la plus importante à suivre est la différence entre votre perte de formation (imprimée pendant la formation) et la perte de validation (imprimée de temps en temps lorsque le RNN est exécuté sur les données de validation (par défaut toutes les 1000 itérations)). En particulier:
Les deux paramètres les plus importants qui contrôlent le modèle sont rnn_size et num_layers . Je vous conseille d'utiliser toujours num_layers de l'un ou l'autre 2/3. Le rnn_size peut être ajusté en fonction de la quantité de données dont vous disposez. Les deux quantités importantes pour garder une trace ici sont:
Ces deux devraient être à peu près le même ordre de grandeur. C'est un peu difficile à dire. Voici quelques exemples:
rnn_size plus grand.La stratégie gagnante pour obtenir de très bons modèles (si vous avez le temps de calcul) est de toujours se tromper pour rendre le réseau plus grand (aussi grand que vous êtes prêt à l'attendre), puis d'essayer différentes valeurs d'abandon (entre 0,1). Quel que soit le modèle, les meilleures performances de validation (la perte, écrite dans le nom de fichier de point de contrôle, Low is Good) est celle que vous devez utiliser à la fin.
Il est très courant dans l'apprentissage en profondeur d'exécuter de nombreux modèles différents avec de nombreux paramètres d'hyperparamètre différents, et en fin de compte, prendre le point de contrôle a donné les meilleures performances de validation.
Soit dit en passant, la taille de vos divisions d'entraînement et de validation est également des paramètres. Assurez-vous d'avoir une quantité décente de données dans votre ensemble de validation ou autrement, les performances de validation seront bruyantes et non très informatives.
Mit
