Essayez d'exécuter LeNet-5 MNIST de TensorFlow, AlexNet MNIST sur AWS EC2 t2.micro (pour l'offre gratuite)

introduction

TensorFlow est un système d'apprentissage en profondeur développé par Google et publié sous une licence Apache 2.0. Il prend en charge GPU, C ++ et Python.

"J'ai utilisé le GPU pour le déplacer croustillant!"

Comme il existe de nombreux articles tels que, j'ai osé installer TensorFlow (version Python, Anaconda) sur AWS EC2 t2.micro (pour le niveau d'utilisation gratuite) et l'exécuter. J'espère que cela vous aidera à comprendre les crédits CPU de votre instance AWS EC2 T2.

LeNet-5, MNIST Cette fois, exemple de programme tensorflow/models/image/mnist/convolutional.py Travailler. Le modèle LeNet-5 ressemble à ceci. (Source)

MNIST est un ensemble de données de nombres manuscrits 0-9. (BASE DE DONNÉES MNIST) Il existe 60 000 données de formation et 10 000 données d'évaluation.

LeNet-5 et le MNIST sont publiés dans cet article.

[LeCun et al., 1998] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, november 1998

En utilisant cet exemple TensorFlow (convolutional.py), nous pouvons obtenir un taux de réponse correct d'environ 99,2%.

• Lors de l'apprentissage de MNIST avec scikit-learn svm, le taux de réponse correct est d'environ 97%. Cependant, l'apprentissage en profondeur prend des dizaines ou des centaines de fois plus de temps d'apprentissage.

Installez TensorFlow sur AWS EC2

1. WS EC2 Ubuntu Server 16.04 LTS (HVM), SSD Volume Type ⇒ t2.micro Choisir.

2. Paramètres Putty (pour les utilisateurs de Windows)

• Session > Host Name
  ubuntu@[public_dns_name]
• Connection > SSH > Auth > Authentication parameters > Private key file for authentication
  [*.ppk file]

3. Anaconda + TensorFlow Installez TensorFlow sur Anaconda au cas où vous souhaiteriez utiliser Python plus tard.

• ** Télécharger Anaconda **

  $ mkdir tensorflow
  $ cd tensorflow
  $ curl https://repo.continuum.io/archive/Anaconda3-4.2.0-Linux-x86_64.sh -o Anaconda3-4.2.0-Linux-x86_64.sh
  

• ** Installation d'Anaconda ** Il vous sera demandé d'accepter la licence, le chemin d'installation et de définir PATH dans .bashrc.

  $ bash Anaconda3-4.2.0-Linux-x86_64.sh
  >>> (ENTER)
  >>> yes
  [/home/ubuntu/anaconda3] >>> (ENTER)
  PATH in your /home/ubuntu/.bashrc ? [yes|no]
  [no] >>> yes
  

Après l'installation, déconnectez-vous et connectez-vous pour reconnaître votre PATH. Vérifiez le fonctionnement d'Anaconda.

```
$ conda -V
conda 4.2.9
```

• ** Installation de TensorFlow ** Créez un environnement tensorflow dans Anaconda.

  $ conda create -n tensorflow python=3.5
  Proceed ([y]/n)? y
  

Installez TensorFlow dans l'environnement tensorflow d'Anaconda.

```
$ source activate tensorflow
(tensorflow)$ conda install -c conda-forge tensorflow

The following NEW packages will be INSTALLED:

    mkl:        11.3.3-0
    mock:       2.0.0-py35_0   conda-forge
    numpy:      1.11.2-py35_0
    pbr:        1.10.0-py35_0  conda-forge
    protobuf:   3.0.0b2-py35_0 conda-forge
    six:        1.10.0-py35_0  conda-forge
    tensorflow: 0.10.0-py35_0  conda-forge

Proceed ([y]/n)? y
```

À propos, voici la commande pour mettre fin à l'environnement TensorFlow d'Anaconda.

```
(tensorflow)$ source deactivate
```

Cliquez ici pour la commande permettant de démarrer l'environnement TensorFlow d'Anaconda à partir de la prochaine fois.

```
(tensorflow)$ source activate tensorflow
```

Si vous ne basculez pas vers l'environnement TensorFlow, l'erreur suivante se produit lors de l'exécution de TensorFlow.

```
>>> import tensorflow as tf
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 ImportError: No module named 'tensorflow'
```

Vérifiez le répertoire dans lequel TensorFlow est installé.

```
(tensorflow)$ python -c 'import os; import inspect; import tensorflow; print(os.path.dirname(inspect.getfile(tensorflow)))'
/home/ubuntu/anaconda3/envs/tensorflow/lib/python3.5/site-packages/tensorflow
```

• ** Contrôle de fonctionnement TensorFlow ** Calculons avec Hellow Tensor Flow! Et Tensor Flow.

  $ source activate tensorflow
  (tensorflow)$ python
  ...
  >>> import tensorflow as tf
  >>> hello = tf.constant('Hello, TensorFlow!')
  >>> sess = tf.Session()
  >>> print(sess.run(hello))
  Hello, TensorFlow!
  >>> a = tf.constant(10)
  >>> b = tf.constant(32)
  >>> print(sess.run(a + b))
  42
  

• ** Vérification du fonctionnement TMNIST **

  (tensorflow)$ python /home/ubuntu/anaconda3/envs/tensorflow/lib/python3.5/site-packages/tensorflow/models/image/mnist/convolutional.py --self_test
  Running self-test.
  Initialized!
  Step 0 (epoch 0.00), 6.7 ms
  Minibatch loss: 9.772, learning rate: 0.010000
  Minibatch error: 92.2%
  Validation error: 0.0%
  Test error: 0.0%
  test_error 0.0
  

Maintenant, vous êtes prêt à partir.

Exécutez LeNet-5 MNIST sur AWS EC2 t2.micro

Lançons-le.

(tensorflow) $ python /home/ubuntu/anaconda3/envs/tensorflow/lib/python3.5/site-packages/tensorflow/models/image/mnist/convolutional.py
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting data/train-images-idx3-ubyte.gz
Extracting data/train-labels-idx1-ubyte.gz
Extracting data/t10k-images-idx3-ubyte.gz
Extracting data/t10k-labels-idx1-ubyte.gz
Initialized!
Step 0 (epoch 0.00), 6.8 ms
Minibatch loss: 12.053, learning rate: 0.010000
Minibatch error: 90.6%
Validation error: 84.6%
Step 100 (epoch 0.12), 432.6 ms
Minibatch loss: 3.276, learning rate: 0.010000
Minibatch error: 6.2%
Validation error: 7.2%
Step 200 (epoch 0.23), 435.2 ms
Minibatch loss: 3.457, learning rate: 0.010000
Minibatch error: 14.1%
Validation error: 3.9%
Step 300 (epoch 0.35), 430.3 ms
Minibatch loss: 3.204, learning rate: 0.010000
Minibatch error: 6.2%
Validation error: 3.1%
Step 400 (epoch 0.47), 431.9 ms
Minibatch loss: 3.211, learning rate: 0.010000
Minibatch error: 9.4%
Validation error: 2.5%

L'apprentissage se déroulera sans heurts. L'état est affiché toutes les 100 étapes.

En fin de compte, l'objectif est de réduire l'erreur de validation.

Les paramètres du programme sont les suivants.

L'apprentissage se déroulera sans heurts pendant un moment, mais la vitesse d'apprentissage ralentira à 1/10 en cours de route.

Step 5000 (epoch 5.82), 434.0 ms
Step 5100 (epoch 5.93), 431.1 ms
Step 5200 (epoch 6.05), 430.0 ms
Step 5300 (epoch 6.17), 434.3 ms
Step 5400 (epoch 6.28), 533.1 ms
Step 5500 (epoch 6.40), 581.7 ms
Step 5600 (epoch 6.52), 581.4 ms
Step 5700 (epoch 6.63), 580.6 ms
Step 5800 (epoch 6.75), 582.4 ms
Step 5900 (epoch 6.87), 785.4 ms
Step 6000 (epoch 6.98), 975.2 ms
Step 6100 (epoch 7.10), 969.0 ms
Step 6200 (epoch 7.21), 2485.7 ms
Step 6300 (epoch 7.33), 4477.5 ms
Step 6400 (epoch 7.45), 4492.2 ms
Step 6500 (epoch 7.56), 3791.0 ms
Step 6600 (epoch 7.68), 4414.7 ms
Step 6700 (epoch 7.80), 4485.0 ms
Step 6800 (epoch 7.91), 4259.3 ms
Step 6900 (epoch 8.03), 3942.3 ms

En regardant la surveillance, l'utilisation du processeur était de 100% au début, mais elle est limitée à 10% au milieu.

Il y a beaucoup de mémoire dans l'instance t2.micro.

$ free -h
              total        used        free      shared  buff/cache   available
Mem:           990M        374M        372M        4.4M        243M        574M
Swap:            0B          0B          0B

Crédit CPU

Restrictions de crédit CPU

Si vous vérifiez le solde créditeur du processeur, vous pouvez voir que les 30 comptes initialement facturés ont été épuisés.

** Solde créditeur CPU **

** Utilisation du crédit CPU **

Alors, que signifie la valeur du crédit CPU? En fait, cette valeur représente une économie sur le nombre de minutes que vous pouvez utiliser votre CPU à 100%. Ainsi, pendant que les crédits CPU sont facturés, si vous regardez le graphique de l'utilisation des crédits CPU, vous consommez 5 comptes toutes les 5 minutes.

Le processeur utilisé dans t2.micro est «Intel (R) Xeon (R) CPU E5-2676 v3 @ 2.40GHz».

$ cat /proc/cpuinfo | grep "model name"
model name      : Intel(R) Xeon(R) CPU E5-2676 v3 @ 2.40GHz

Et t2.micro a le droit de profiter de 10% des performances du processeur. Quant à l'allocation de 10%, 6 comptes de crédits CPU sont alloués par heure. Un comptage vous donne le droit d'utiliser 100% du processeur pendant une minute, donc six comptages en une heure (60 minutes) correspondent exactement à 10%.

Vous pouvez économiser jusqu'à 24 heures de solde de crédit CPU. Avec t2.micro, vous pouvez stocker jusqu'à 144 comptes (6 comptes / heure x 24 heures). Immédiatement après la création de l'instance t2.micro, environ 30 comptes sont alloués. Si vous arrêtez l'instance, le crédit CPU sera remis à 0.

Il faut environ 60 minutes pour exécuter LeNet-5 MINIST de TensorFlow sur t2.micro et continuer à utiliser 100% du CPU. Si vous créez une instance et exécutez le LeNet-5 MINIST de TensorFlow tel quel, vous serez sur 30 comptes de crédits CPU. Dans t2.micro, qui a été arrêté et les crédits CPU ont été remis à 0, 60 comptes de crédits CPU sont insuffisants.

Immédiatement après la création d'une instance, il faut environ 6 heures pour attendre 5 heures pour accumuler 30 comptes, puis continuer à s'exécuter à une vitesse lente même si 30 comptes sont insuffisants. Il n'y a aucune différence entre l'heure de fin et l'heure de démarrage de l'instance.

Considérez comment utiliser efficacement les crédits CPU

Réfléchissons à la façon d'utiliser efficacement le CPU, compte tenu des restrictions des crédits CPU.

1. ** Créez une nouvelle instance ** Si vous souhaitez simplement gagner des crédits CPU, sauvegardez sur l'AMI et recréez l'instance en fonction de l'AMI à chaque fois, et vous obtiendrez 30 comptes au début.

2. ** Utilisez le temps de ralentissement (15 minutes) ** Pour gagner du temps sur le processeur sans trop modifier le programme, vous pouvez utiliser un ralentissement de plus de 15 minutes. Si le crédit du processeur devient 0 lorsque le taux d'utilisation du processeur est de 100%, le taux d'utilisation du processeur sera limité à 10% sur 15 minutes. Lorsque le crédit CPU devient 0, si le programme est arrêté une fois jusqu'à ce que le crédit CPU soit accordé dans une certaine mesure, les performances du CPU de 10% ou plus peuvent être utilisées pendant 15 minutes avec le crédit CPU étant 0. Ainsi, le calcul se poursuivra un peu. Cependant, cette méthode a un revers. Premièrement, si la période d'utilisation de 100% du processeur est courte, elle ralentira de 100% à 10% en peu de temps. De plus, le taux d'utilisation du processeur ne passe pas soudainement de 0% à 100% même avec des crédits CPU, et il faut environ 6 minutes pour passer de 0% à 100%. La limite d'utilisation du processeur prend 15 minutes pour passer d'une constante 100% à 10%, mais il ne faut que 5 minutes pour passer d'un momentané de 40% à 10%. Pour que l'utilisation du CPU atteigne 100%, il est nécessaire d'accumuler des crédits CPU pendant 6 minutes, et il est nécessaire d'arrêter le calcul pendant 60 minutes. Si vous continuez le calcul à basse vitesse pendant 60 minutes, le calcul pendant 6 minutes se déroulera en termes de 100% CPU, mais si vous arrêtez le CPU, le calcul de ce montant ne se poursuivra pas. La méthode de répétition de l'arrêt et du démarrage du calcul est "** pas très efficace **" car la vitesse de ralentissement de l'utilisation du processeur est rapide et il faut un certain temps pour démarrer l'utilisation du processeur. Il semble. Essayez d'ajouter le traitement de veille suivant.

       start_time = time.time()
       ．．．
       cpu_start_time = time.time() #★ Heure de début
       for step in xrange(int(num_epochs * train_size) // BATCH_SIZE):
           ．．．
           if step % EVAL_FREQUENCY == 0:
               elapsed_time = time.time() - start_time
               avrg_time = 1000 * elapsed_time / EVAL_FREQUENCY
               ．．．
               #★ Veille pendant 50 minutes lorsque le temps de calcul moyen dépasse 3000 msec
               if avrg_time > 3000:
                   print("sleep t2.micro cpu. passed time=%d" % (time.time() - cpu_start_time))
                   time.sleep(3000)
                   print("run t2.micro cpu. passed time=%d" % (time.time() - cpu_start_time))
               
               start_time = time.time()
   

Le graphique ressemble à ceci. Au lieu de calculer lentement de 10%, 100% est calculé instantanément.

** L'utilisation du processeur **

** Utilisation du crédit CPU **

** Solde créditeur CPU **

3. ** Relayer plusieurs instances ** Le système sera compliqué, mais il semble efficace d'utiliser la fonction d'alarme d'AWS pour basculer lors de la génération / suppression de tc2.micro et enregistrer la progression dans S3. Cependant, il semble que certaines personnes disent qu'il vaut mieux payer pour une instance performante que de fabriquer un tel système.
4. ** Créez une instance à l'avance ** Si vous démarrez t2.micro pendant 24 heures sans rien faire, les crédits CPU seront accumulés jusqu'à 144 points. Si le calcul tient dans les 144 minutes, vous pouvez créer une instance la veille et la laisser seule.
5. AWS Lambda Vous devez conserver votre demande dans les 300 secondes, mais si vous pouvez bien le faire, c'est probablement une option. Si vous exécutez Lambda sur le même processeur que EC2 t2.micro, il semble que vous puissiez l'utiliser si vous pouvez calculer en le divisant toutes les 500 étapes. Le temps de calcul est d'environ 230 secondes, 60 secondes pour le chargement et la sauvegarde de la progression du calcul et 10 secondes pour la pièce de rechange. Ce calcul est OK si vous avez 512 Mo de mémoire, vous pouvez donc calculer en continu pendant 9 jours avec la trame libre de Lambda. Cependant, la tarification de Lambda est différente de EC2. Dans le cas de Lambda, plus vous avez de mémoire, plus votre processeur sera rapide. Je souhaite réduire autant que possible le nombre de commutateurs toutes les 300 secondes. Ensuite, l'utilisation de la limite supérieure de 1536 Mo de mémoire réduira le nombre de commutateurs. Si vous utilisez 1536 Mo de mémoire, le niveau gratuit pour un mois sera de 3 jours (266 667 secondes). Cliquez ici pour consulter les résultats de l'enquête sur les spécifications des machines AWS Lambda (lien).

AlexNet MNIST Ensuite, exécutez le benchmark AlexNet MNIST sur EC2 t2.micro (pour l'offre gratuite) et comparez-le au GPU. Le programme se présente comme suit dans le répertoire d'installation de tensorflow.

tensorflow/models/image/alexnet/alexnet_benchmark.py

Selon les commentaires du programme, le GPU semble avoir de telles performances.

Forward pass:
Run on Tesla K40c: 145 +/- 1.5 ms / batch
Run on Titan X:     70 +/- 0.1 ms / batch

Forward-backward pass:
Run on Tesla K40c: 480 +/- 48 ms / batch
Run on Titan X:    244 +/- 30 ms / batch

D'autre part, le journal de la console qui a exécuté EC2 t2.micro ressemble à ceci. Même si EC2 t2.micro fonctionne à 100% du CPU, il y a une différence d'environ 100 fois entre le GPU et EC2 t2.micro.

conv1   [128, 56, 56, 64]
pool1   [128, 27, 27, 64]
conv2   [128, 27, 27, 192]
pool2   [128, 13, 13, 192]
conv3   [128, 13, 13, 384]
conv4   [128, 13, 13, 256]
conv5   [128, 13, 13, 256]
pool5   [128, 6, 6, 256]
2016-10-24 16:18:03.743222: step 10, duration = 9.735
2016-10-24 16:19:40.927811: step 20, duration = 9.675
2016-10-24 16:21:17.593104: step 30, duration = 9.664
2016-10-24 16:22:53.894240: step 40, duration = 9.684
2016-10-24 16:24:29.968737: step 50, duration = 9.597
2016-10-24 16:26:06.527066: step 60, duration = 9.686
2016-10-24 16:27:43.229298: step 70, duration = 9.689
2016-10-24 16:29:19.643403: step 80, duration = 9.679
2016-10-24 16:30:56.202710: step 90, duration = 9.588
2016-10-24 16:32:22.877673: Forward across 100 steps, 9.553 +/- 0.962 sec / batch
2016-10-24 16:42:27.229588: step 10, duration = 28.700
2016-10-24 16:49:33.216683: step 20, duration = 72.885
．．．

Ensuite, autour de l'étape 20 de Avant-arrière, le crédit CPU 30 est utilisé. Après cela, il ralentit progressivement, il fonctionne à 10% du processeur et le calcul se poursuit sans fin à une vitesse de 1/1000 du GPU. Hmmm. Ce ne sera pas du tout un match.

en conclusion

Changeons un peu le point de vue.

Comment puis-je avoir un sentiment d'accomplissement en exécutant LeNet-5 MNIST de TensorFlow (convolutional.py) sur AWS EC2 t2.micro (niveau gratuit)?

Immédiatement après la création d'une instance, il y a 30 crédits CPU, alors configurons-le pour que le calcul soit terminé dans 30 à 40 minutes.

Modifié convolutif.py

NUM_EPOCHS = 6

C'est vrai. Il n'y a qu'un seul changement. C'est OK si vous définissez le nombre d'apprentissage pour être dans le crédit CPU.

Amusons-nous dans la vie de Deep Learning avec TensorFlow! !!