Compartilhamento de tecnologia

[AIGC] 2. Mac usa GPU localmente para iniciar cálculos de keras

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Mac usa GPU localmente para iniciar a computação Keras

1. Contexto do problema

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.

2. Formação técnica

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

3. Verificação experimental

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.

Configuração nativa

Os parâmetros de software e hardware da máquina Mac usada desta vez são os seguintes:
Insira a descrição da imagem aqui

Instalar PlaidML

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.

Instale plaidml-keras

pip3  install plaidml-keras
  • 1

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

Configurar placa gráfica padrão

Executar na linha de comando

plaidml-setup
  • 1

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]:
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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!
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Pressione Enter para gravar as informações de configuração no arquivo de configuração padrão para concluir a configuração.

Execute código que usa computação de CPU

Nesta seção, o Jupyter é usado para executar um código de algoritmo simples e seu tempo é contado.

Passo 1 Primeiro importe o pacote keras e importe os dados cifar10. Isso pode envolver o download da rede externa. Se você tiver alguma dúvida, consulte-o.Perguntas básicas sobre o uso de keras
#!/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)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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.

Passo 2 Importe o modelo de cálculo Se os dados do modelo não existirem localmente, eles serão baixados automaticamente. Se você tiver alguma dúvida, consulte-os.Perguntas básicas sobre o uso de keras
model = kapp.VGG19()
  • 1
compilação do modelo step3
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
  • 1
passo 4 Faça uma previsão
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
  • 1
  • 2

Executando o lote inicial (compilando o programa de blocos)
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/passo

passo 5 Faça 10 previsões
# 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
  • 2
  • 3
  • 4
  • 5

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

Execute código usando computação GPU

Usando placa gráfica metal_intel®_uhd_graphics_630.0

etapa 0 Importe keras por meio do plaidml e, em seguida, execute as operações relacionadas ao keras
# Importing PlaidML. Make sure you follow this order
import plaidml.keras
plaidml.keras.install_backend()
import os
os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
  • 1
  • 2
  • 3
  • 4
  • 5

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.

passo 1 Primeiro importe o pacote keras e importe os dados cifar10
#!/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)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
step2 Importe o modelo de cálculo Se os dados do modelo não existirem localmente, eles serão baixados automaticamente.
model = kapp.VGG19()
  • 1

Gere informações da placa gráfica na primeira execução

INFO:plaidml:Dispositivo de abertura “metal_intel®_uhd_graphics_630.0”

compilação do modelo step3
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
  • 1
passo 4 Faça uma previsão
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
  • 1
  • 2

Executando o lote inicial (compilando o programa de blocos)

Como a saída é mais rápida, apenas uma linha de conteúdo é impressa.

passo 5 Faça 10 previsões
# 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
  • 2
  • 3
  • 4
  • 5

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

Usando placa gráfica metal_amd_radeon_pro_5300m.0

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!
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
etapa 0 Importe keras por meio do plaidml e, em seguida, execute as operações relacionadas ao keras
# Importing PlaidML. Make sure you follow this order
import plaidml.keras
plaidml.keras.install_backend()
import os
os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
  • 1
  • 2
  • 3
  • 4
  • 5

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.

passo 1 Primeiro importe o pacote keras e importe os dados cifar10
#!/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)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
step2 Importe o modelo de cálculo Se os dados do modelo não existirem localmente, eles serão baixados automaticamente.
model = kapp.VGG19()
  • 1

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.

compilação do modelo step3
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
  • 1
passo 4 Faça uma previsão
print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)
  • 1
  • 2

Executando o lote inicial (compilando o programa de blocos)

Como a saída é mais rápida, apenas uma linha de conteúdo é impressa.

passo 5 Faça 10 previsões
# 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
  • 2
  • 3
  • 4
  • 5

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

4. Discussão de Avaliação

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.