Le framework de Deep Learning de Microsoft "CNTK" est désormais compatible avec Python, ce qui le rend beaucoup plus facile à utiliser

Connaissez-vous CNTK? Pour ceux qui ont déjà utilisé une sorte de framework de Deep Learning, je pense que la plupart d'entre eux disent: "Je sais que la SEP existe ...".

En fait, quand je demande aux gens autour de moi, il semble que le coût d'apprentissage soit élevé pour ceux qui ont vu des articles écrits en DSL avant la sortie de la version. Il semble que beaucoup de gens ne comprennent pas le type de fonctionnalités dont ils disposent, car il existe peu de documents japonais sur CNTK en premier lieu.

Par conséquent, dans cet article, je voudrais présenter CNTK, qui est devenu plus facile à utiliser car compatible avec Python, en saupoudrant des mots-clés tels que ses fonctionnalités et ses différences par rapport aux autres frameworks.

"Open-source, Cross-platform Toolkit"

Environnement de développement ouvert

Il est open source et est en cours de développement sur GitHub.

Environnement de développement multiplateforme

Disponible sur Linux et Windows. Docker pour Linux (https://hub.docker.com/r/microsoft/cntk/) est également disponible.

Diverses interfaces

Les éléments suivants sont actuellement pris en charge:

• C++
• Brainscript
• Python (NEW!)

Il est passé à la version 2.0 en octobre 2016, et enfin Python est également pris en charge! (Larmes) Je pense que de nombreux ingénieurs qui utilisent l'apprentissage automatique sont des utilisateurs de Python, donc C ++ peut quand même être utilisé avec Brainscript! Même si on le dit, environ 132 personnes sur 100 devraient être "Burein Sukuriputo ... ??". Cependant, je pense que le coût d'apprentissage a immédiatement baissé grâce au support de Python.

"Scalability"

Je pense que la chose la plus intéressante à propos de CNTK est son évolutivité.

Microsoft Research Blog

La figure ci-dessus est une comparaison des vitesses d'apprentissage par chaque framework (*). Nous comparons le nombre d'images pouvant être traitées par seconde par un réseau neuronal à 4 couches entièrement connecté. Avec un seul GPU, la vitesse est presque la même pour chaque framework, mais avec plusieurs machines / plusieurs GPU, vous pouvez voir que CNTK est extrêmement plus élevé que les autres.

• Comparaison en décembre 2015

"Benchmarking State-of-the-Art Deep Learning Software Tools"

De plus, il s'agit d'une référence pour AlexNet, ResNet et LSTM entièrement connectés (*). Vous pouvez voir que CNTK a les performances les plus rapides en jointure complète et LSTM. À propos, AlexNet était le plus rapide avec Caffe, et ResNet était le plus rapide avec Torch. Le benchmark montre également que CNTK est un pionnier du framework Deep Learning sur tous les modèles et surpasse le TensorFlow le plus connu. (C'était assez surprenant ...)

• Comparaison en août 2016

"Efficient network authoring" CNTK a conçu ce qui suit afin de créer un réseau neuronal aussi efficacement et facilement que possible.

• ** Composabilité qui vous permet de construire n'importe quel réseau de neurones en combinant des composants simples **
• ** Gérez le réseau neuronal comme un objet fonction **

Par exemple, supposons qu'un réseau de neurones à propagation directe avec deux couches cachées soit exprimé par une formule mathématique comme suit.

Dans CNTK, vous pouvez écrire sous une forme similaire à une formule mathématique.

h1 = Sigmoid(W1  * x  + b1)
h2 = Sigmoid(W2  * h1 + b2)
P = Softmax(Wout * h2 + bout)

ce = CrossEntropy(y, P, tag='criterion')

Puisque CNTK traite les réseaux neuronaux comme des objets fonctionnels, il est très compatible avec la description des réseaux neuronaux (y compris les réseaux neuronaux profonds) qui sont des «fonctions» très grandes et complexes. Et grâce au support Python, vous pouvez écrire la structure de votre réseau neuronal de manière plus concise.

Par exemple, ce qui suit est un exemple d'image d'un réseau de réseau neuronal convolutif (CNN) couramment utilisé dans les systèmes de reconnaissance d'image.

Si vous écrivez la configuration réseau ci-dessus directement dans CNTK,

def create_basic_model(input, out_dims):
    
    net = Convolution((5,5), 32, init=glorot_uniform(), activation=relu, pad=True)(input)
    net = MaxPooling((3,3), strides=(2,2))(net)

    net = Convolution((5,5), 32, init=glorot_uniform(), activation=relu, pad=True)(net)
    net = MaxPooling((3,3), strides=(2,2))(net)

    net = Convolution((5,5), 64, init=glorot_uniform(), activation=relu, pad=True)(net)
    net = MaxPooling((3,3), strides=(2,2))(net)
    
    net = Dense(64, init=glorot_uniform())(net)
    net = Dense(out_dims, init=glorot_uniform(), activation=None)(net)
    
    return net

Vous pouvez écrire comme ça. Cependant, cela rend le code plus redondant à mesure que le nombre de couches cachées augmente. Comme je l'ai dit plus tôt, CNTK est tellement concentré sur la *** composabilité *** que vous pouvez l'écrire plus simplement et plus efficacement:

def create_model(input, out_dims):

    with default_options(activation=relu):
        model = Sequential([
            For(range(3), lambda i: [
                Convolution((5,5), [32,32,64][i], init=glorot_uniform(), pad=True),
                MaxPooling((3,3), strides=(2,2))
            ]),
            Dense(64, init=glorot_uniform()),
            Dense(out_dims, init=glorot_uniform(), activation=None)
        ])

    return model(input)

Utilisez Sequential () pour regrouper chaque couche connectée sur une ligne droite horizontale, ou si vous souhaitez utiliser la même fonction d'activation ou le même biais dans plusieurs couches, utilisez default_options () pour implémenter la précédente. Je peux écrire le réseau plus efficacement que l'exemple.

En outre, dans CNTK, les composants tels que CNN, ResNet et RNN qui sont généralement utilisés sont préparés comme des API (*), donc c'est très pour ** "ceux qui comprennent le réseau neuronal lui-même dans une certaine mesure" **. C'est un mécanisme qui facilite les choses.

• J'ai écrit une API Python typique pour CNTK comme [Annexe] en bas, donc veuillez vérifier ce qui est disponible si vous le souhaitez.

"Efficient execution"

Comme mentionné ci-dessus, l'un des avantages de l'utilisation de CNTK est la haute performance telle que la vitesse d'apprentissage rapide pendant l'entraînement et l'utilisation efficace de plusieurs GPU, mais ceux-ci sont uniques à CNTK comme suit. Parce qu'il a la fonction de.

• ** Convertissez en représentation graphique et apprenez **
• ** Algorithme d'apprentissage parallèle propriétaire **

Apprenez en convertissant en représentation graphique

h1 = Sigmoid(W1  * x  + b1)
h2 = Sigmoid(W2  * h1 + b2)
P = Softmax(Wout * h2 + bout)

ce = CrossEntropy(y, P, tag='criterion')

Je vais réimprimer le réseau de neurones à propagation directe avec deux couches cachées, que j'ai pris comme exemple plus tôt. Dans CNTK, le script ci-dessus est d'abord converti en une représentation appelée graphique de calcul, comme indiqué ci-dessous.

À ce stade, les nœuds du graphique sont des fonctions et les arêtes sont les valeurs. En convertissant d'abord la représentation graphique de cette manière,

• ** Apprentissage par différenciation automatique **
• ** La pré-optimisation réduit la mémoire d'exécution et les coûts de calcul **

Peut être réalisé.

Équipé d'un algorithme d'apprentissage parallèle unique

Block-Momentum SGD

Microsoft Research Blog

À partir de CNTK version 1.5 [Block-Momentum SGD](https://www.microsoft.com/en-us/research/publication/scalable-training-deep-learning-machines-incremental-block-training-intra-block- Il implémente une technologie appelée Parallel-Optimization-Blockwise-Model-Update-Filtering /).

Cela élimine considérablement le coût de la communication entre les GPU et permet des vitesses plus rapides sur plusieurs GPU tout en maintenant la précision.

En fait, la tâche ci-dessus montre des performances 50 fois meilleures lorsqu'elle est exécutée sur 64 clusters GPU que sur un seul.

1-bit SGD Le goulot d'étranglement dans le traitement distribué sur le GPU concerne les coûts de communication. Cependant, CNTK est [SGD 1 bit](https://www.microsoft.com/en-us/research/publication/1-bit-stochastic-gradient-descent-and-application-to-data-parallel-distributed -training-of-speech-dnns /), une technologie qui permet d'éliminer les coûts de communication en quantifiant le gradient à 1 bit est implémentée. En conséquence, la vitesse d'apprentissage pendant l'apprentissage du réseau neuronal peut être améliorée de sorte que le coût de communication peut être considérablement réduit lors de l'exécution d'un traitement parallèle.

en conclusion

Qu'as-tu pensé. J'ai présenté les fonctionnalités de CNTK avec quelques points, mais je pense que vous ne le saviez peut-être pas. Qu'est-ce que CNTK cette fois? Depuis que je me suis concentré, je n'ai pas abordé la création de l'environnement, mais le support de python a rendu la création de l'environnement beaucoup plus facile. De plus, le didacticiel basé sur Jupyter Notebook est très riche, donc si vous êtes intéressé par CNTK après avoir lu cet article, essayez CNTK dans le didacticiel! Si vous avez des questions sur la construction de l'environnement ou le tutoriel, Faites une conversion de style avec MS Deep Learning Framework CNTK-Et si vous vous laissez dessiner Goch à l'école primaire? et Didacticiel "CNTK" de Microsoft Deep Learning Library sont décrits en détail. Veuillez y jeter un œil.

Ce serait formidable si le nombre de personnes qui liront cet article et diront: "Touchons CNTK un instant" augmentera autant que possible! :)

[Annexe] Exemple d'API Python pour CNTK

• basic blocks:
  • LTSM(), GRU(), RNNUnit()
  • ForwardDeclaration(), Tensor[], SparseTensor[], Sequence[], SequenceOver[]
• layers:
  • Dence(), Embedding()
  • Convolution(), Convolution1D(), convolution3D(), Deconvolution()
  • MaxPooling(), AveragePooling(), GlobalMaxPooling(), GlobalAveragePooling(), MaxUnpooling()
  • BatchNormalization(), LayerNormalization()
  • Dropout(), Activation()
  • Label()
• composition:
  • Sequential(), For()
  • ResNetBlock(), SequentialClique()
• sequences:
  • Delay(), PastValueWindows()
  • Recurrence(), RecurrencFrom(), Fold(), UnfoldFrom()
• models:
  • AttentionModel()