minhas informações de contato
Correspondência[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
No artigo anterior, descobrimos que na operação de modelos grandes, ao utilizar a CPU para operação, o uso da CPU é muito alto. Portanto, pensaremos aqui que se houver uma placa gráfica GPU na máquina, como podemos aproveitar as vantagens da placa gráfica em operações vetoriais e realizar operações relacionadas ao aprendizado de máquina de maneira rápida e adequada.
Sabemos que as placas gráficas convencionais atuais que suportam aprendizado de máquina são placas gráficas da série Nvida, comumente conhecidas como placas N. No entanto, em máquinas Mac, as placas gráficas da série AMD geralmente são integradas. A diferença entre dois conjuntos de instruções de hardware diferentes leva à necessidade de diferentes tecnologias de implementação na camada superior.
Mas nas placas gráficas AMD existe uma tecnologia PlaidML, através deste plug-in, as diferenças das diferentes placas gráficas podem ser encapsuladas.
Endereço do projeto PlaidML: https://github.com/plaidml/plaidml
Atualmente, PlaidML já oferece suporte a ferramentas como Keras, ONNX e nGraph. Você pode usar Keras diretamente para construir um modelo e seu MacBook pode facilmente chamar a GPU.
Através desta ferramenta chamada PlaidML, o treinamento de aprendizagem profunda pode ser facilmente realizado independentemente das placas gráficas NVIDIA, AMD ou Intel.
referir-se:Mac acelera o treinamento de aprendizagem por reforço com PlaidML
Nesta operação, para um algoritmo keras convencional, múltiplas rodadas de cálculos são realizadas na CPU e GPU, respectivamente, e as estatísticas são demoradas. Faça estatísticas comparativas.
Os parâmetros de software e hardware da máquina Mac usada desta vez são os seguintes:
Como o processo de instalação de pacotes dependentes requer interação de comando, a instalação do pacote plaidML é realizada na linha de comando e a execução do código é realizada em jupyter.
Como o Jupyter terá pontos técnicos que exigem a criação do kernel ao usar um ambiente virtual, é recomendável usar diretamente o ambiente Python original para verificação por enquanto. Os alunos que entendem as características de configuração do Jupyter em um ambiente virtual podem tentar operá-lo em um ambiente virtual.
pip3 install plaidml-keras
Após o autor utilizar o comando pip3 install plaidml-keras para instalar a versão mais recente do plaidml-keras, que é 0.7.0, encontrei um bug ao realizar a operação de inicialização Posteriormente, foi reduzido para 0.6.4 e a execução foi. normal. Mas então instalei novamente como 0.7.0 e voltou ao normal.
plaidml no github
Executar na linha de comando
plaidml-setup
O conteúdo interativo é o seguinte
(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]:
Liste as placas gráficas atualmente suportadas e escolha entre as 2 placas gráficas suportadas por padrão ou todos os 6 hardwares suportados na fase experimental.
Você pode ver as duas placas gráficas suportadas por padrão, que são as duas placas gráficas reais na captura de tela inicial. Para fins de estabilidade do teste, selecione N primeiro e pressione Enter.
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
Para as configurações padrão selecionadas, defina um dispositivo padrão. Aqui primeiro definimos metal_intel®_uhd_graphics_630.0 como o dispositivo padrão. É claro que o desempenho deste dispositivo é relativamente baixo. comparação.
Depois de escrever 1, pressione Enter.
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!
Pressione Enter para gravar as informações de configuração no arquivo de configuração padrão para concluir a configuração.
Nesta seção, o Jupyter é usado para executar um código de algoritmo simples e seu tempo é contado.
#!/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)
Observe que o back-end de computação keral padrão aqui deve usar tensorflow, verifique a saída
2024-07-11 14:36:02.753107: I tensorflow/core/platform/cpu_feature_guard.cc:210] Este binário TensorFlow é otimizado para usar instruções de CPU disponíveis em operações críticas de desempenho.
Para habilitar as seguintes instruções: AVX2 FMA, em outras operações, reconstrua o TensorFlow com os sinalizadores do compilador apropriados.
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)
Executando o lote inicial (compilando o programa de blocos)
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/passo
# 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 ━━━━━━━━━━━━━━━━━━━━ 1s 891ms/passo
Correu em 0,9295139312744141 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 923ms/passo
Correu em 1,8894760608673096 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 893ms/passo
Correu em 2,818492889404297 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 932ms/passo
Correu em 3,7831668853759766 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 892ms/passo
Correu em 4,71358585357666 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 860ms/passo
Correu em 5,609835863113403 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 878ms/passo
Correu em 6,5182459354400635 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 871ms/passo
Correu em 7,423128128051758 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 896ms/passo
Correu em 8,352543830871582 segundos
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 902ms/passo
Correu em 9,288795948028564 segundos
# Importing PlaidML. Make sure you follow this order
import plaidml.keras
plaidml.keras.install_backend()
import os
os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
Observação:
1. Quando a versão plaidml=0.7.0 for usada, ocorrerá um erro na operação plaidml.keras.install_backend().
2. Nesta etapa, o keras será importado por meio do plaidml e o mecanismo de computação em segundo plano será definido como plaidml em vez de tensorflow.
#!/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()
Gere informações da placa gráfica na primeira execução
INFO:plaidml:Dispositivo de abertura “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)
Executando o lote inicial (compilando o programa de blocos)
Como a saída é mais rápida, apenas uma linha de conteúdo é impressa.
# 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))
Correu em 4,241918087005615 segundos
Correu em 8,452141046524048 segundos
Correu em 12,665411949157715 segundos
Correu em 16,849968910217285 segundos
Correu em 21.025720834732056 segundos
Correu em 25,212764024734497 segundos
Correu em 29,405478954315186 segundos
Correu em 33,594977140426636 segundos
Correu em 37,7886438369751 segundos
Correu em 41,98136305809021 segundos
No estágio de seleção da placa gráfica na configuração plaidml-setup, a placa gráfica metal_intel®_uhd_graphics_630.0 não está mais selecionada, mas metal_amd_radeon_pro_5300m.0 está selecionado.
(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"
Observação:
1. Quando a versão plaidml=0.7.0 for usada, ocorrerá um erro na operação plaidml.keras.install_backend().
2. Nesta etapa, o keras será importado por meio do plaidml e o mecanismo de computação em segundo plano será definido como plaidml em vez de tensorflow.
#!/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:Dispositivo de abertura “metal_amd_radeon_pro_5300m.0”
Observe que as informações da placa gráfica são inseridas aqui pela primeira vez.
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)
Executando o lote inicial (compilando o programa de blocos)
Como a saída é mais rápida, apenas uma linha de conteúdo é impressa.
# 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))
Ver resultado
Correu em 0,43606019020080566 segundos
Correu em 0,8583459854125977 segundos
Correu em 1,2787911891937256 segundos
Correu em 1,70143723487854 segundos
Correu em 2,1235032081604004 segundos
Correu em 2,5464580059051514 segundos
Correu em 2,9677979946136475 segundos
Correu em 3,390064001083374 segundos
Correu em 3,8117799758911133 segundos
Correu em 4,236911058425903 segundos
O valor de memória da placa gráfica metal_intel®_uhd_graphics_630.0 é 1536 MB. Embora seja uma placa gráfica, seu desempenho em cálculos não é tão bom quanto o CPU de 6 núcleos desta máquina;
A placa gráfica metal_amd_radeon_pro_5300m.0 tem um valor de memória de 4G Comparado com a CPU nativa, seu desempenho é quase 1 vez maior.
A partir disso podemos ver as vantagens poderosas do uso de GPUs em operações de aprendizado de máquina.
Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.
Correspondência[email protected]