2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Dans l'article précédent, nous avons découvert que lors du fonctionnement de grands modèles, lors de l'utilisation du processeur pour le fonctionnement, l'utilisation du processeur est très élevée. Par conséquent, nous réfléchirons ici que s'il y a une carte graphique GPU dans la machine, comment pouvons-nous profiter de la carte graphique dans les opérations vectorielles et effectuer rapidement et bien les opérations liées à l'apprentissage automatique.
Nous savons que les cartes graphiques grand public actuelles qui prennent en charge l'apprentissage automatique sont les cartes graphiques de la série Nvida, communément appelées cartes N. Cependant, sur les machines Mac, les cartes graphiques de la série AMD sont généralement intégrées. La différence entre deux jeux d’instructions matérielles différents conduit à la nécessité de technologies d’implémentation différentes dans la couche supérieure.
Mais dans les cartes graphiques AMD, il existe une technologie PlaidML, grâce à ce plug-in, les différences entre les différentes cartes graphiques peuvent être encapsulées.
Adresse du projet PlaidML : https://github.com/plaidml/plaidml
À l'heure actuelle, PlaidML prend déjà en charge des outils tels que Keras, ONNX et nGraph. Vous pouvez directement utiliser Keras pour créer un modèle et votre MacBook peut facilement appeler le GPU.
Grâce à cet outil appelé PlaidML, la formation en deep learning peut être facilement réalisée quelles que soient les cartes graphiques NVIDIA, AMD ou Intel.
faire référence à:Mac utilise PlaidML pour accélérer la formation par apprentissage par renforcement
Dans cette opération, pour un algorithme keras conventionnel, plusieurs séries de calculs sont effectuées respectivement sur le CPU et le GPU, et les statistiques prennent du temps. Faites des statistiques comparatives.
Les paramètres logiciels et matériels de la machine Mac utilisée cette fois sont les suivants :
Étant donné que le processus d'installation des packages dépendants nécessite une interaction de commande, l'installation du package plaidML est effectuée sur la ligne de commande et l'exécution du code est effectuée dans jupyter.
Étant donné que jupyter aura des points techniques qui nécessiteront la création d'un noyau lors de l'utilisation d'un environnement virtuel, il est recommandé d'utiliser directement l'environnement python d'origine pour la vérification pour le moment. Les étudiants qui comprennent les caractéristiques de configuration de jupyter dans un environnement virtuel peuvent essayer de le faire fonctionner dans un environnement virtuel.
pip3 install plaidml-keras
Après que l'auteur ait utilisé la commande pip3 install plaidml-keras pour installer la dernière version de plaidml-keras, qui est la 0.7.0, j'ai rencontré un bug lors de l'exécution de l'opération d'initialisation. Par la suite, il a été réduit à 0.6.4 et l'exécution a été réduite. normale. Mais après l'avoir réinstallé vers la version 0.7.0, c'était à nouveau normal.
plaidml sur github
Exécuter en ligne de commande
plaidml-setup
Le contenu interactif est le suivant
(venv) tsingj@tsingjdeMacBook-Pro-2 ~ # plaidml-setup
PlaidML Setup (0.6.4)
Thanks for using PlaidML!
Some Notes:
* Bugs and other issues: https://github.com/plaidml/plaidml
* Questions: https://stackoverflow.com/questions/tagged/plaidml
* Say hello: https://groups.google.com/forum/#!forum/plaidml-dev
* PlaidML is licensed under the Apache License 2.0
Default Config Devices:
metal_intel(r)_uhd_graphics_630.0 : Intel(R) UHD Graphics 630 (Metal)
metal_amd_radeon_pro_5300m.0 : AMD Radeon Pro 5300M (Metal)
Experimental Config Devices:
llvm_cpu.0 : CPU (LLVM)
metal_intel(r)_uhd_graphics_630.0 : Intel(R) UHD Graphics 630 (Metal)
opencl_amd_radeon_pro_5300m_compute_engine.0 : AMD AMD Radeon Pro 5300M Compute Engine (OpenCL)
opencl_cpu.0 : Intel CPU (OpenCL)
opencl_intel_uhd_graphics_630.0 : Intel Inc. Intel(R) UHD Graphics 630 (OpenCL)
metal_amd_radeon_pro_5300m.0 : AMD Radeon Pro 5300M (Metal)
Using experimental devices can cause poor performance, crashes, and other nastiness.
Enable experimental device support? (y,n)[n]:
Répertoriez les cartes graphiques actuellement prises en charge et choisissez entre les 2 cartes graphiques prises en charge par défaut ou les 6 matériels pris en charge en phase expérimentale.
Vous pouvez voir les deux cartes graphiques prises en charge par défaut, qui sont les deux cartes graphiques réelles dans la capture d'écran initiale. Par souci de stabilité du test, sélectionnez d’abord N et appuyez sur Entrée.
Multiple devices detected (You can override by setting PLAIDML_DEVICE_IDS).
Please choose a default device:
1 : metal_intel(r)_uhd_graphics_630.0
2 : metal_amd_radeon_pro_5300m.0
Default device? (1,2)[1]:1
Selected device:
metal_intel(r)_uhd_graphics_630.0
Pour les paramètres sélectionnés par défaut, définissez un périphérique par défaut. Ici, nous définissons d'abord metal_intel®_uhd_graphics_630.0 comme périphérique par défaut. Bien sûr, les performances de cet appareil sont en fait relativement médiocres. Plus tard, nous définirons metal_amd_radeon_pro_5300m.0 comme périphérique par défaut. comparaison.
Après avoir écrit 1, appuyez sur Entrée.
Almost done. Multiplying some matrices...
Tile code:
function (B[X,Z], C[Z,Y]) -> (A) { A[x,y : X,Y] = +(B[x,z] * C[z,y]); }
Whew. That worked.
Save settings to /Users/tsingj/.plaidml? (y,n)[y]:y
Success!
Appuyez sur Entrée pour écrire les informations de configuration dans le fichier de configuration par défaut afin de terminer la configuration.
Dans cette section, jupyter est utilisé pour exécuter un code d'algorithme simple et son temps est compté.
#!/usr/bin/env python
import numpy as np
import os
import time
import keras
import keras.applications as kapp
from keras.datasets import cifar10
(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()
batch_size = 8
x_train = x_train[:batch_size]
x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)
Notez que le backend informatique Keral par défaut doit utiliser Tenserflow, vérifiez la sortie
2024-07-11 14:36:02.753107 : I tensorflow/core/platform/cpu_feature_guard.cc:210] Ce binaire TensorFlow est optimisé pour utiliser les instructions CPU disponibles dans les opérations critiques en termes de performances.
Pour activer les instructions suivantes : AVX2 FMA, dans d’autres opérations, reconstruisez TensorFlow avec les indicateurs de compilateur appropriés.
model = kapp.VGG19()
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
Exécution du lot initial (compilation du programme de tuiles)
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 1 s/étape
# Now start the clock and run 10 batchesprint("Timing inference...")
start = time.time()
for i in range(10):
y = model.predict(x=x_train, batch_size=batch_size)
print("Ran in {} seconds".format(time.time() - start))
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 891 ms/pas
Exécuté en 0,9295139312744141 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 923 ms/pas
Exécuté en 1,8894760608673096 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 893 ms/pas
Exécuté en 2,818492889404297 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 932 ms/pas
Exécuté en 3,7831668853759766 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 892 ms/pas
Exécuté en 4,71358585357666 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 860 ms/pas
Exécuté en 5,609835863113403 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 878 ms/pas
Exécuté en 6,5182459354400635 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 871 ms/pas
Exécuté en 7,423128128051758 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 896 ms/pas
Exécuté en 8,352543830871582 secondes
1/1 ━━━━━━━━━━━━━━━━━━━━ 1 s 902 ms/pas
Exécuté en 9,288795948028564 secondes
# Importing PlaidML. Make sure you follow this order
import plaidml.keras
plaidml.keras.install_backend()
import os
os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
Note:
1. Lorsque la version plaidml=0.7.0 est utilisée, une erreur se produira lors de l'opération plaidml.keras.install_backend().
2. Dans cette étape, les keras seront importés via plaidml et le moteur de calcul en arrière-plan sera défini sur plaidml au lieu de tenserflow.
#!/usr/bin/env python
import numpy as np
import os
import time
import keras
import keras.applications as kapp
from keras.datasets import cifar10
(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()
batch_size = 8
x_train = x_train[:batch_size]
x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)
model = kapp.VGG19()
Afficher les informations de la carte graphique lors de la première exécution
INFO:plaidml:Ouverture du périphérique « metal_intel®_uhd_graphics_630.0 »
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
Exécution du lot initial (compilation du programme de tuiles)
La sortie étant plus rapide, une seule ligne de contenu est imprimée.
# Now start the clock and run 10 batchesprint("Timing inference...")
start = time.time()
for i in range(10):
y = model.predict(x=x_train, batch_size=batch_size)
print("Ran in {} seconds".format(time.time() - start))
Exécuté en 4,241918087005615 secondes
Exécuté en 8,452141046524048 secondes
Exécuté en 12,665411949157715 secondes
Exécuté en 16,849968910217285 secondes
Couru en 21,025720834732056 secondes
Exécuté en 25,212764024734497 secondes
Exécuté en 29,405478954315186 secondes
Exécuté en 33,594977140426636 secondes
Exécuté en 37,7886438369751 secondes
Exécuté en 41,98136305809021 secondes
Lors de l'étape de sélection de la carte graphique dans le paramètre plaidml-setup, la carte graphique metal_intel®_uhd_graphics_630.0 n'est plus sélectionnée, mais metal_amd_radeon_pro_5300m.0 est sélectionnée.
(venv) tsingj@tsingjdeMacBook-Pro-2 ~ # plaidml-setup
PlaidML Setup (0.6.4)
Thanks for using PlaidML!
Some Notes:
* Bugs and other issues: https://github.com/plaidml/plaidml
* Questions: https://stackoverflow.com/questions/tagged/plaidml
* Say hello: https://groups.google.com/forum/#!forum/plaidml-dev
* PlaidML is licensed under the Apache License 2.0
Default Config Devices:
metal_intel(r)_uhd_graphics_630.0 : Intel(R) UHD Graphics 630 (Metal)
metal_amd_radeon_pro_5300m.0 : AMD Radeon Pro 5300M (Metal)
Experimental Config Devices:
llvm_cpu.0 : CPU (LLVM)
metal_intel(r)_uhd_graphics_630.0 : Intel(R) UHD Graphics 630 (Metal)
opencl_amd_radeon_pro_5300m_compute_engine.0 : AMD AMD Radeon Pro 5300M Compute Engine (OpenCL)
opencl_cpu.0 : Intel CPU (OpenCL)
opencl_intel_uhd_graphics_630.0 : Intel Inc. Intel(R) UHD Graphics 630 (OpenCL)
metal_amd_radeon_pro_5300m.0 : AMD Radeon Pro 5300M (Metal)
Using experimental devices can cause poor performance, crashes, and other nastiness.
Enable experimental device support? (y,n)[n]:n
Multiple devices detected (You can override by setting PLAIDML_DEVICE_IDS).
Please choose a default device:
1 : metal_intel(r)_uhd_graphics_630.0
2 : metal_amd_radeon_pro_5300m.0
Default device? (1,2)[1]:2
Selected device:
metal_amd_radeon_pro_5300m.0
Almost done. Multiplying some matrices...
Tile code:
function (B[X,Z], C[Z,Y]) -> (A) { A[x,y : X,Y] = +(B[x,z] * C[z,y]); }
Whew. That worked.
Save settings to /Users/tsingj/.plaidml? (y,n)[y]:y
Success!
# Importing PlaidML. Make sure you follow this order
import plaidml.keras
plaidml.keras.install_backend()
import os
os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
Note:
1. Lorsque la version plaidml=0.7.0 est utilisée, une erreur se produira lors de l'opération plaidml.keras.install_backend().
2. Dans cette étape, les keras seront importés via plaidml et le moteur de calcul en arrière-plan sera défini sur plaidml au lieu de tenserflow.
#!/usr/bin/env python
import numpy as np
import os
import time
import keras
import keras.applications as kapp
from keras.datasets import cifar10
(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()
batch_size = 8
x_train = x_train[:batch_size]
x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)
model = kapp.VGG19()
INFO:plaidml:Ouverture du périphérique « metal_amd_radeon_pro_5300m.0 »
Notez que les informations de la carte graphique sont saisies ici pour la première fois.
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
Exécution du lot initial (compilation du programme de tuiles)
La sortie étant plus rapide, une seule ligne de contenu est imprimée.
# Now start the clock and run 10 batchesprint("Timing inference...")
start = time.time()
for i in range(10):
y = model.predict(x=x_train, batch_size=batch_size)
print("Ran in {} seconds".format(time.time() - start))
Afficher la sortie
Exécuté en 0,43606019020080566 secondes
Exécuté en 0,8583459854125977 secondes
Exécuté en 1,2787911891937256 secondes
Exécuté en 1,70143723487854 secondes
Exécuté en 2,1235032081604004 secondes
Exécuté en 2,5464580059051514 secondes
Exécuté en 2,9677979946136475 secondes
Exécuté en 3,390064001083374 secondes
Exécuté en 3,8117799758911133 secondes
Exécuté en 4,236911058425903 secondes
La valeur de mémoire de la carte graphique metal_intel®_uhd_graphics_630.0 est de 1536 Mo. Bien qu'en tant que carte graphique, ses performances en calculs ne soient pas aussi bonnes que le processeur à 6 cœurs de cette machine ;
La carte graphique metal_amd_radeon_pro_5300m.0 a une valeur de mémoire de 4G. Par rapport au processeur natif, ses performances sont près de 1 fois supérieures.
De là, nous pouvons voir les puissants avantages de l’utilisation du GPU dans les opérations d’apprentissage automatique.
Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.
