Einführung

TensorFlow ist ein von Google entwickeltes Deep-Learning-System, das unter einer Apache 2.0-Lizenz veröffentlicht wird. Es unterstützt GPU, C ++ und Python.

"Ich habe die GPU benutzt, um sie knusprig zu machen!"

Da es viele Beiträge wie gibt, habe ich es gewagt, TensorFlow (Python-Version, Anaconda) auf AWS EC2 t2.micro (für die kostenlose Nutzung) zu installieren und auszuführen. Ich hoffe, es hilft Ihnen, die CPU-Credits Ihrer AWS EC2 T2-Instanz zu verstehen.

LeNet-5, MNIST Diesmal Beispielprogramm tensorflow/models/image/mnist/convolutional.py Arbeiten. Das Modell LeNet-5 sieht so aus. (Quelle)

MNIST ist ein Datensatz mit handschriftlichen Zahlen 0-9. (MNIST DATABASE) Es gibt 60.000 Trainingsdaten und 10.000 Bewertungsdaten.

In diesem Artikel werden sowohl LeNet-5 als auch MNIST veröffentlicht.

[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

Mit dieser TensorFlow-Stichprobe (convolutional.py) können wir eine korrekte Antwortrate von ca. 99,2% erreichen.

Beim Erlernen von MNIST mit scikit-learn svm liegt die korrekte Antwortrate bei etwa 97%. Deep Learning dauert jedoch zehn- oder hundertmal länger.

Installieren Sie TensorFlow auf AWS EC2

WS EC2 Ubuntu Server 16.04 LTS (HVM), SSD Volume Type ⇒ t2.micro Wählen.

2. Kitteinstellungen (für Windows-Benutzer)

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

Anaconda + TensorFlow Installieren Sie TensorFlow auf Anaconda, falls Sie Python später verwenden möchten.

** Anaconda herunterladen **

$ 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

** Anaconda Installation ** Sie werden aufgefordert, die Lizenz zu akzeptieren, den Pfad zu installieren und PATH in .bashrc festzulegen.

$ 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

Melden Sie sich nach der Installation ab und wieder an, um Ihren PFAD zu erkennen. Überprüfen Sie die Funktion von Anaconda.

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

** TensorFlow-Installation ** Erstellen Sie eine Tensorflow-Umgebung in Anaconda.
```
$ conda create -n tensorflow python=3.5
Proceed ([y]/n)? y
```

Installieren Sie TensorFlow in der Tensorflow-Umgebung von 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
```

Übrigens, hier ist der Befehl zum Beenden der TensorFlow-Umgebung von Anaconda.

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

Klicken Sie hier, um den Befehl zum Starten der TensorFlow-Umgebung von Anaconda ab dem nächsten Mal anzuzeigen.

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

Wenn Sie nicht zur TensorFlow-Umgebung wechseln, tritt beim Ausführen von TensorFlow der folgende Fehler auf.

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

Überprüfen Sie das Verzeichnis, in dem TensorFlow installiert ist.

```
(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
```

** TensorFlow-Funktionsprüfung ** Berechnen wir mit Hellow Tensor Flow! Und 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

** TMNIST-Funktionsprüfung **

(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

Jetzt können Sie loslegen.

Führen Sie LeNet-5 MNIST auf AWS EC2 t2.micro aus

Lass es uns laufen.

(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%

Das Lernen wird reibungslos verlaufen. Der Status wird alle 100 Schritte angezeigt.

Artikel	Bedeutung
Step	Anzahl des Lernens
epoch	Häufigkeit, mit der alle Trainingsdaten verwendet wurden
ms	Durchschnittliche Zeit für eine Studie
Minibatch loss	Anzahl der Trainingsdaten verdünnt
learning rate	Parameter, wie sorgfältig Sie mit dem Lernen fortfahren
Minibatch error	Fehlerrate der Trainingsdaten
Validation error	Validierungsdatenfehlerrate

Letztendlich ist das Ziel, den Validierungsfehler zu reduzieren.

Die Programmparameter sind wie folgt.

Artikel	Aufbau
Ausgangsbedingungen	Epoche>10
Chargengröße	64
Aktivierungsfunktion	ReLU

Das Lernen wird für eine Weile reibungslos verlaufen, aber die Lerngeschwindigkeit wird sich unterwegs auf 1/10 verlangsamen.

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

Bei der Überwachung lag die CPU-Auslastung zu Beginn bei 100%, in der Mitte jedoch bei 10%. SlowRun_CPU使用率.png

In der t2.micro-Instanz ist viel Speicher vorhanden.

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

CPU-Guthaben

CPU-Kreditbeschränkungen

Wenn Sie das Guthaben der CPU überprüfen, können Sie feststellen, dass die ursprünglich berechneten 30 Zählungen aufgebraucht sind.

** CPU-Guthaben ** SlowRun_CPUクレジット残高.png

** CPU-Guthabenauslastung ** SlowRun_CPUクレジット使用状況.png

Was bedeutet der CPU-Kreditwert? Tatsächlich bedeutet dieser Wert eine Einsparung, wie viele Minuten Sie Ihre CPU zu 100% nutzen können. Während also die CPU-Guthaben aufgeladen werden, verbrauchen Sie alle 5 Minuten 5 Zählungen, wenn Sie sich das Diagramm der CPU-Guthabenauslastung ansehen.

Die in t2.micro verwendete CPU ist "Intel (R) Xeon (R) CPU E5-2676 v3 bei 2,40 GHz".

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

Und t2.micro hat das Recht, 10% der CPU-Leistung zu nutzen. Für die Zuweisung von 10% werden 6 Stunden CPU-Guthaben pro Stunde vergeben. Eine Zählung gibt Ihnen das Recht, eine Minute lang 100% der CPU zu nutzen, sodass sechs Zählungen in einer Stunde (60 Minuten) genau 10% betragen.

Sie können bis zu 24 Stunden CPU-Guthaben sparen. Mit t2.micro können Sie bis zu 144 Zählungen (6 Zählungen / Stunde x 24 Stunden) speichern. Unmittelbar nach dem Erstellen der t2.micro-Instanz werden ca. 30 Zählungen zugewiesen. Wenn Sie die Instanz stoppen, wird das CPU-Guthaben auf 0 gelöscht.

Es dauert ungefähr 60 Minuten, um TensorFlows LeNet-5 MINIST auf t2.micro auszuführen und weiterhin 100% der CPU zu nutzen. Wenn Sie eine Instanz erstellen und den LeNet-5 MINIST von TensorFlow so ausführen, wie er ist, sind 30 CPU-Credits nicht mehr vorhanden. In t2.micro, das gestoppt und die CPU-Credits auf 0 gelöscht wurden, sind 60 CPU-Credits nicht ausreichend.

Unmittelbar nach dem Erstellen einer Instanz dauert es ungefähr 6 Stunden, 5 Stunden zu warten, um 30 Zählungen zu akkumulieren, und dann mit langsamer Geschwindigkeit weiterzulaufen, selbst wenn 30 Zählungen nicht ausreichen. Es gibt keinen Unterschied in der Endzeit und der Startzeit der Instanz.

Überlegen Sie, wie Sie CPU-Credits effizient nutzen können

Lassen Sie uns überlegen, wie Sie die CPU unter Berücksichtigung der Einschränkungen der CPU-Gutschriften effizient nutzen können.

** Neue Instanz erstellen ** Wenn Sie nur CPU-Credits verdienen möchten, sichern Sie sich das AMI und erstellen Sie die Instanz jedes Mal basierend auf dem AMI neu. Zu Beginn erhalten Sie 30 Zählungen.
** Verwenden Sie die Verlangsamungszeit (15 Minuten) ** Um die Anzahl der CPUs zu erhöhen, ohne das Programm zu stark zu ändern, können Sie die Verlangsamung über 15 Minuten verwenden. Wenn das CPU-Guthaben 0 wird, wenn die CPU-Auslastungsrate 100% beträgt, wird die CPU-Auslastungsrate innerhalb von 15 Minuten auf 10% begrenzt. Wenn das CPU-Guthaben 0 wird und das Programm einmal gestoppt wird, bis das CPU-Guthaben zu einem gewissen Grad vergeben ist, kann die CPU-Leistung von 10% oder mehr 15 Minuten lang verwendet werden, wobei das CPU-Guthaben 0 ist. Die Berechnung wird also ein wenig fortgesetzt. Diese Methode hat jedoch eine Rückseite. Erstens, wenn der Zeitraum von 100% CPU-Auslastung kurz ist, wird er in kurzer Zeit von 100% auf 10% verlangsamt. Außerdem steigt die CPU-Auslastungsrate auch bei CPU-Gutschriften nicht plötzlich von 0% auf 100%, und es dauert ungefähr 6 Minuten, um von 0% auf 100% zu steigen. Das CPU-Auslastungslimit dauert 15 Minuten, um von konstant 100% auf 10% zu gelangen, aber es dauert nur 5 Minuten, um von momentan 40% auf 10% zu gelangen. Damit die CPU-Auslastung 100% erreicht, müssen 6 Minuten lang CPU-Credits angesammelt und die Berechnung für 60 Minuten gestoppt werden. Wenn Sie die Berechnung 60 Minuten lang mit niedriger Geschwindigkeit fortsetzen, wird die Berechnung für 6 Minuten in Bezug auf 100% CPU fortgesetzt. Wenn Sie jedoch die CPU stoppen, wird die Berechnung für diesen Betrag nicht fortgesetzt. Die Methode zum Wiederholen des Stopps und Starts der Berechnung ist "** nicht sehr effektiv **", da die Verlangsamungsgeschwindigkeit der CPU-Auslastung schnell ist und das Starten der CPU-Auslastung eine gewisse Zeit in Anspruch nimmt. Es scheint, dass. Versuchen Sie, die folgende Schlafverarbeitung hinzuzufügen.
```
    start_time = time.time()
    ．．．
    cpu_start_time = time.time() #★ Startzeit
    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
            ．．．
            #★ Schlafen Sie 50 Minuten lang, wenn die durchschnittliche Berechnungszeit 3000 ms überschreitet
            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()
```

Das Diagramm sieht so aus. Anstatt 10% langsam zu berechnen, werden 100% sofort berechnet.

** CPU auslastung ** Sleep_CPU Usage.png

** CPU-Guthabenauslastung ** Sleep_CPU Credit Usage.png

** CPU-Guthaben ** Sleep_CPU Credit Balance.png

** Mehrere Instanzen weiterleiten ** Als System wird es kompliziert sein, aber es scheint effektiv zu sein, die Alarmfunktion von AWS zu verwenden, um beim Generieren / Löschen von tc2.micro zu wechseln und den Fortschritt in S3 zu speichern. Es scheint jedoch, dass einige Leute sagen, dass es besser ist, für eine Hochleistungsinstanz zu bezahlen, um ein solches System zu mieten.
** Erstellen Sie eine Instanz im Voraus ** Wenn Sie t2.micro 24 Stunden lang starten und nichts tun, werden CPU-Credits bis zu 144 Zählungen angesammelt. Wenn die Berechnung innerhalb von 144 Minuten passt, können Sie am Vortag eine Instanz erstellen und in Ruhe lassen.
AWS Lambda Sie müssen Ihre Anfrage innerhalb von 300 Sekunden behalten, aber wenn Sie dies gut können, ist dies wahrscheinlich eine Option. Wenn Sie Lambda auf derselben CPU wie EC2 t2.micro ausführen, können Sie es anscheinend verwenden, wenn Sie es berechnen können, indem Sie es alle 500 Schritte teilen. Die Berechnungszeit beträgt ca. 230 Sekunden, 60 Sekunden zum Laden und Speichern des Berechnungsfortschritts und 10 Sekunden für den Ersatz. Diese Berechnung ist in Ordnung, wenn Sie über 512 MB Speicher verfügen, sodass Sie mit Lambdas freiem Frame 9 Tage lang kontinuierlich rechnen können. Die Preise von Lambda unterscheiden sich jedoch von denen von EC2. Bei Lambda ist Ihre CPU umso schneller, je mehr Speicher Sie haben. Ich möchte die Anzahl der Schalter alle 300 Sekunden so weit wie möglich reduzieren. Wenn Sie dann die Obergrenze von 1536 MB Speicher verwenden, wird die Anzahl der Switches reduziert. Wenn Sie 1536 MB Speicher verwenden, beträgt die kostenlose Stufe für einen Monat 3 Tage (266.667 Sekunden). Klicken Sie hier, um die Ergebnisse der AWS Lambda-Umfrage zu Maschinenspezifikationen anzuzeigen (Link).

AlexNet MNIST Führen Sie als Nächstes den AlexNet MNIST-Benchmark auf EC2 t2.micro (kostenlos) aus und vergleichen Sie ihn mit der GPU. Das Programm ist wie folgt im Installationsverzeichnis von Tensorflow.

tensorflow/models/image/alexnet/alexnet_benchmark.py

Laut den Kommentaren des Programms scheint die GPU eine solche Leistung zu haben.

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

Auf der anderen Seite sieht das Konsolenprotokoll, auf dem EC2 t2.micro ausgeführt wurde, folgendermaßen aus. Selbst wenn EC2 t2.micro mit 100% CPU ausgeführt wird, gibt es einen etwa 100-fachen Unterschied zwischen GPU und 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
．．．

Um Schritt 20 von Vorwärts-Rückwärts wird dann das CPU-Guthaben 30 aufgebraucht. Danach verlangsamt es sich allmählich, arbeitet mit 10% CPU und die Berechnung wird endlos mit 1/1000 GPU-Geschwindigkeit fortgesetzt. Hmmm. Es wird überhaupt kein Match sein.

abschließend

Lassen Sie uns den Standpunkt ein wenig ändern.

Wie kann ich ein Erfolgserlebnis erzielen, wenn ich TensorFlows LeNet-5 MNIST (convolutional.py) auf AWS EC2 t2.micro (kostenlose Stufe) ausführe?

Unmittelbar nach dem Erstellen einer Instanz sind 30 CPU-Credits vorhanden. Stellen Sie diese also so ein, dass die Berechnung in 30 bis 40 Minuten abgeschlossen ist.

`Modifizierte Faltung.py`


NUM_EPOCHS = 6

Korrekt. Es gibt nur eine Änderung. Es ist in Ordnung, wenn Sie die Anzahl der Lernvorgänge so einstellen, dass sie innerhalb des CPU-Guthabens liegen.

Lass uns ein lustiges Deep Learning-Leben mit TensorFlow haben! !!

[PYTHON] Versuchen Sie, TensorFlows LeNet-5 MNIST, AlexNet MNIST auf AWS EC2 t2.micro auszuführen (kostenlos)