tensorlayer tricks

Comment utiliser TensorLayer

Alors que la recherche en Deep Learning continue d'améliorer le monde, nous utilisons un tas de trucs pour mettre en œuvre des algorithmes avec le tensorlayer au jour le jour.

Voici un résumé des astuces pour utiliser TensorLayer. Si vous trouvez une astuce particulièrement utile dans la pratique, veuillez ouvrir une demande de traction pour l'ajouter au document. Si nous le trouvons raisonnable et vérifiée, nous le fusionnerons.

• ?? 《深度学习 ： 一起玩转 TensorLayer 》已上架。

1. Installation

• Pour garder votre version TL et modifier facilement le code source, vous pouvez télécharger l'intégralité du référentiel en excutant git clone https://github.com/zsdonghao/tensorlayer.git dans votre terminal, puis copiez le dossier tensorlayer dans votre projet
• À mesure que TL se développe très rapidement, si vous souhaitez utiliser pip Installer, nous vous suggérons d'installer la version maître
• Pour l'application NLP, vous devrez installer des données NLTK et NLTK

2. Interaction entre TF et Tl

• TF à TL: Utilisez Inputlayer
• TL à TF: Utilisez le réseau.outputs
• Autres méthodes Problèmes 7, problèmes d'entrées multiples31

3. Commutation de formation / test

• Utilisez Network.all_drop pour contrôler la phase de formation / test (pour Dropoutlayer uniquement) Voir cet exemple et comprendre la couche de base
• Alternativement, Set is_fix sur True dans Dropoutlayer et créez différents graphiques pour la formation / les tests en réutilisant les paramètres. Vous pouvez également définir différents batch_size et une probabilité de bruit pour différents graphiques. Cette méthode est la meilleure lorsque vous utilisez GaussianNoiseLayer, BatchNormlayer et etc. Voici un exemple:

 def mlp ( x , is_train = True , reuse = False ):
    with tf . variable_scope ( "MLP" , reuse = reuse ):
      net = InputLayer ( x , name = 'in' )
      net = DropoutLayer ( net , 0.8 , True , is_train , name = 'drop1' )
      net = DenseLayer ( net , n_units = 800 , act = tf . nn . relu , name = 'dense1' )
      net = DropoutLayer ( net , 0.8 , True , is_train , name = 'drop2' )
      net = DenseLayer ( net , n_units = 800 , act = tf . nn . relu , name = 'dense2' )
      net = DropoutLayer ( net , 0.8 , True , is_train , name = 'drop3' )
      net = DenseLayer ( net , n_units = 10 , act = tf . identity , name = 'out' )
      logits = net . outputs
      net . outputs = tf . nn . sigmoid ( net . outputs )
      return net , logits
x = tf . placeholder ( tf . float32 , shape = [ None , 784 ], name = 'x' )
y_ = tf . placeholder ( tf . int64 , shape = [ None , ], name = 'y_' )
net_train , logits = mlp ( x , is_train = True , reuse = False )
net_test , _ = mlp ( x , is_train = False , reuse = True )
cost = tl . cost . cross_entropy ( logits , y_ , name = 'cost' )

Plus ici.

4. Obtenez des variables et des sorties

• Utilisez tl.layers.get_variables_with_name au lieu d'utiliser net.all_params

 train_vars = tl . layers . get_variables_with_name ( 'MLP' , True , True )
train_op = tf . train . AdamOptimizer ( learning_rate = 0.0001 ). minimize ( cost , var_list = train_vars )

• Cette méthode peut également être utilisée pour geler certaines couches pendant l'entraînement, tout simplement ne pas obtenir des variables
• Autres méthodes Issues17, problèmes26, FQA
• Utilisez tl.layers.get_layers_with_name pour obtenir la liste des sorties d'activation d'un réseau.

 layers = tl . layers . get_layers_with_name ( network , "MLP" , True )

• Cette méthode est généralement utilisée pour la régularisation de l'activation.

5. Augmentation des données pour un grand ensemble de données

Si votre ensemble de données est important, le chargement des données et l'augmentation des données deviendront le col de bas et ralentiront la formation. Pour accélérer le traitement des données, vous pouvez:

• Utilisez des exemples Tfrecord ou TF, voir des exemples de CIFAR10

6. Augmentation des données pour un petit ensemble de données

Si votre taille de données est suffisamment petite pour alimenter la mémoire de votre machine et que l'augmentation des données est simple. Pour déboguer facilement, vous pouvez:

• Utilisez tl.iterate.minibatches pour mélanger et retourner les exemples et les étiquettes par le lot donné.
• Utilisez tl.prepro.threading_data pour lire un lot de données au début de chaque étape, les performances sont lentes mais bonnes pour le petit ensemble de données.
• Pour les données de séries chronologiques, utilisez tl.iterate.seq_minibatches, tl.iterate.seq_minibatches2, tl.iterate.ptb_iterator et etc.

7. CNN et Resnet pré-formés

• CNN pré-formé
• De nombreuses applications font le besoin de modèle CNN pré-formé
• TL fournit un VGG16 pré-formé, VGG19, Mobilenet, Squeezenet et etc.: TL.Models
• tl.layers.slimnetslayer vous permet d'utiliser tous les modèles pré-formés TF-SLIM et les modèles TensorLayer / Pretraind
• Resnet
• Implémenté par "pour" Loop Issues85
• Autres méthodes par @ritchieng

8. Utilisation de tl.models

• Utilisez VGG16 pré-entraîné pour la classification ImageNet

 x = tf . placeholder ( tf . float32 , [ None , 224 , 224 , 3 ])
# get the whole model
vgg = tl . models . VGG16 ( x )
# restore pre-trained VGG parameters
sess = tf . InteractiveSession ()
vgg . restore_params ( sess )
# use for inferencing
probs = tf . nn . softmax ( vgg . outputs )

• Extraire les fonctionnalités avec VGG16 et recycler un classificateur avec 100 classes

 x = tf . placeholder ( tf . float32 , [ None , 224 , 224 , 3 ])
# get VGG without the last layer
vgg = tl . models . VGG16 ( x , end_with = 'fc2_relu' )
# add one more layer
net = tl . layers . DenseLayer ( vgg , 100 , name = 'out' )
# initialize all parameters
sess = tf . InteractiveSession ()
tl . layers . initialize_global_variables ( sess )
# restore pre-trained VGG parameters
vgg . restore_params ( sess )
# train your own classifier (only update the last layer)
train_params = tl . layers . get_variables_with_name ( 'out' )

• Modèle de réutilisation

 x1 = tf . placeholder ( tf . float32 , [ None , 224 , 224 , 3 ])
x2 = tf . placeholder ( tf . float32 , [ None , 224 , 224 , 3 ])
# get VGG without the last layer
vgg1 = tl . models . VGG16 ( x1 , end_with = 'fc2_relu' )
# reuse the parameters of vgg1 with different input
vgg2 = tl . models . VGG16 ( x2 , end_with = 'fc2_relu' , reuse = True )
# restore pre-trained VGG parameters (as they share parameters, we don’t need to restore vgg2)
sess = tf . InteractiveSession ()
vgg1 . restore_params ( sess )

9. Couche personnalisée

• 1. Écrivez directement une couche TL
• 2. Utilisez Lambdalayer, il peut également accepter des fonctions avec de nouvelles variables. Avec cette couche, vous pouvez connecter toutes les bibliothèques TF tierces et votre fonction personnalisée à TL. Voici un exemple d'utilisation de Keras et TL ensemble.

 import tensorflow as tf
import tensorlayer as tl
from keras . layers import *
from tensorlayer . layers import *
def my_fn ( x ):
    x = Dropout ( 0.8 )( x )
    x = Dense ( 800 , activation = 'relu' )( x )
    x = Dropout ( 0.5 )( x )
    x = Dense ( 800 , activation = 'relu' )( x )
    x = Dropout ( 0.5 )( x )
    logits = Dense ( 10 , activation = 'linear' )( x )
    return logits

network = InputLayer ( x , name = 'input' )
network = LambdaLayer ( network , my_fn , name = 'keras' )
...

10. Tokenisation des phrases

• Utilisez tl.nlp.process_sence pour tokenize les phrases, les données NLTK et NLTK sont requises

 > >> captions = [ "one two , three" , "four five five" ] # 2个 句 子 
> >> processed_capts = []
> >> for c in captions :
> >>    c = tl . nlp . process_sentence ( c , start_word = "<S>" , end_word = "</S>" )
> >>    processed_capts . append ( c )
> >> print ( processed_capts )
... [[ '<S>' , 'one' , 'two' , ',' , 'three' , '</S>' ],
... [ '<S>' , 'four' , 'five' , 'five' , '</S>' ]]

• Puis utilisez tl.nlp.create_vocab pour créer un vocabulaire et enregistrer en tant que fichier txt (il renverra un objet tl.nlp.simplevocabulary pour l'identifiant de mot uniquement)

 > >> tl . nlp . create_vocab ( processed_capts , word_counts_output_file = 'vocab.txt' , min_word_count = 1 )
... [ TL ] Creating vocabulary .
... Total words : 8
... Words in vocabulary : 8
... Wrote vocabulary file : vocab . txt

• Enfin, utilisez tl.nlp.vocabulary pour créer un objet de vocabulaire à partir du fichier de vocabulaire TXT créé par tl.nlp.create_vocab

 > >> vocab = tl . nlp . Vocabulary ( 'vocab.txt' , start_word = "<S>" , end_word = "</S>" , unk_word = "<UNK>" )
... INFO : tensorflow : Initializing vocabulary from file : vocab . txt
... [ TL ] Vocabulary from vocab . txt : < S > < / S > < UNK >
... vocabulary with 10 words ( includes start_word , end_word , unk_word )
...   start_id : 2
...   end_id : 3
...   unk_id : 9
...   pad_id : 0

Ensuite, vous pouvez cartographier le mot sur ID ou le verset vice comme suit:

 > >> vocab . id_to_word ( 2 )
... 'one'
> >> vocab . word_to_id ( 'one' )
... 2
>> > vocab . id_to_word ( 100 )
... '<UNK>'
> >> vocab . word_to_id ( 'hahahaha' )
... 9

• Plus de fonctions de prétraitement pour les phrases dans tl.prepro et tl.nlp

11. RNN dynamique et longueur de séquence

• Appliquez un rembourrage zéro sur un lot de phrases tokenisées comme suit:

 > >> sequences = [[ 1 , 1 , 1 , 1 , 1 ],[ 2 , 2 , 2 ],[ 3 , 3 ]]
> >> sequences = tl . prepro . pad_sequences ( sequences , maxlen = None , 
...         dtype = 'int32' , padding = 'post' , truncating = 'pre' , value = 0. )
... [[ 1 1 1 1 1 ]
...  [ 2 2 2 0 0 ]
...  [ 3 3 0 0 0 ]]

• Utilisez tl.layers.retrieve_seq_length_op2 pour calculer automatiquement la longueur de séquence à partir de l'espace réservé et le nourrir à la sequence_length de DynamicrnnLayer

 > >> data = [[ 1 , 2 , 0 , 0 , 0 ], [ 1 , 2 , 3 , 0 , 0 ], [ 1 , 2 , 6 , 1 , 0 ]]
> >> o = tl . layers . retrieve_seq_length_op2 ( data )
> >> sess = tf . InteractiveSession ()
> >> tl . layers . initialize_global_variables ( sess )
> >> print ( o . eval ())
... [ 2 3 4 ]

• Autres problèmes de méthodes18

12. Économiser des modèles

• 1. tl.files.save_npz Enregistrer tous les paramètres (poids) de tous les modèles dans la liste AA du tableau, restaurez à l'aide de tl.files.load_and_assign_npz
• 2. tl.files.save_npz_dict Enregistrer tous les paramètres (poids) de tous les modèles dans un dictionnaire de tableau, la clé est le nom du paramètre, restaurer tl.files.load_and_assign_npz_dict
• 3. tl.files.save_ckpt Enregistrer tous les paramètres (poids) du modèle dans le fichier ckpt tensorflow, restaurer tl.files.load_ckpt .

13. Compatibilité avec d'autres emballages TF

TL peut interagir avec d'autres emballages TF, ce qui signifie que si vous trouvez des codes ou des modèles implémentés par d'autres emballages, vous pouvez simplement l'utiliser!

• D'autres implémentations de couche TensorFlow peuvent être connectées à TensorLayer via Lambdalayer, voir l'exemple ici)
• Tf-slim to tl: slimnetslayer (vous pouvez utiliser tous les modèles convolutionnels pré-formés de Google avec cette couche !!!)

14. Autres

• La valeur de decay de BatchNormLayer est de 0,9, réglée sur 0,999 pour un grand ensemble de données.
• Le problème de Matplotlib survient lors de l'importation de problèmes de tensorlayer, voir FQA

Liens utiles

• Awesome-Tensorlayer pour tous les exemples
• TL Sites officiels: Docs, 中文文档, Github
• Apprentissage en profondeur avec TF et TL
• Suivez Zsdonghao pour d'autres exemples

Auteur

• Zhang Rui
• Hao Dong