Programação GPU com Python

Neste artigo, vamos mergulhar na programação de GPU com Python. Usando a facilidade do Python, você pode desbloquear o incrível poder de computação da GPU (unidade de processamento gráfico) da sua placa de vídeo. Neste exemplo, trabalharemos com a biblioteca CUDA da NVIDIA.

Requisitos

Para este exercício, você precisará de uma máquina física com Linux e uma GPU baseada em NVIDIA ou iniciar uma instância baseada em GPU no Amazon Web Services. Ambos devem funcionar bem, mas se você optar por usar uma máquina física, será necessário verificar se os drivers proprietários da NVIDIA estão instalados, consulte as instruções: https: // linuxhint.com / install-nvidia-drivers-linux

Você também precisará do CUDA Toolkit instalado. Este exemplo usa Ubuntu 16.04 LTS especificamente, mas há downloads disponíveis para a maioria das principais distribuições Linux no seguinte URL: https: // developer.nvidia.com / cuda-downloads

Eu prefiro o .download baseado em deb, e estes exemplos irão assumir que você escolheu esse caminho. O arquivo que você baixa é um .pacote deb, mas não tem um .extensão deb, então renomeá-la para ter uma .deb no final é útil. Então você o instala com:

sudo dpkg -i nome do pacote.deb

Se você for solicitado a instalar uma chave GPG, siga as instruções fornecidas para fazer isso.

Agora você precisa instalar o próprio pacote cuda. Para fazer isso, execute:

sudo apt-get update sudo apt-get install cuda -y 

Esta parte pode demorar um pouco, então você pode querer tomar uma xícara de café. Uma vez feito isso, recomendo reiniciar para garantir que todos os módulos sejam recarregados corretamente.

Em seguida, você precisará da distribuição Anaconda Python. Você pode fazer o download aqui: https: // www.anaconda.com / download / # linux

Pegue a versão de 64 bits e instale-a assim:

sh Anaconda *.sh

(a estrela no comando acima garantirá que o comando seja executado independentemente da versão secundária)

O local de instalação padrão deve ser adequado e, neste tutorial, vamos usá-lo. Por padrão, ele é instalado em ~ / anaconda3

No final da instalação, você será solicitado a decidir se deseja adicionar o Anaconda ao seu caminho. Responda sim aqui para tornar a execução dos comandos necessários mais fácil. Para garantir que essa mudança aconteça, depois que o instalador terminar completamente, saia e faça login novamente em sua conta.

Mais informações sobre como instalar o Anaconda: https: // linuxhint.com / install-anaconda-python-on-ubuntu /

Finalmente, precisaremos instalar o Numba. Numba usa o compilador LLVM para compilar Python para código de máquina. Isso não apenas melhora o desempenho do código Python regular, mas também fornece a cola necessária para enviar instruções para a GPU na forma binária. Para fazer isso, execute:

conda instalar numba

Limitações e benefícios da programação GPU

É tentador pensar que podemos converter qualquer programa Python em um programa baseado em GPU, acelerando drasticamente seu desempenho. No entanto, a GPU em uma placa de vídeo funciona de maneira consideravelmente diferente de uma CPU padrão em um computador.

CPUs lidam com muitas entradas e saídas diferentes e têm uma grande variedade de instruções para lidar com essas situações. Eles também são responsáveis ​​por acessar a memória, lidar com o barramento do sistema, lidar com anéis de proteção, segmentação e funcionalidade de entrada / saída. Eles são multitarefas extremas, sem foco específico.

As GPUs, por outro lado, são construídas para processar funções simples com velocidade incrivelmente rápida. Para conseguir isso, eles esperam um estado mais uniforme de entrada e saída. Por se especializar em funções escalares. Uma função escalar recebe uma ou mais entradas, mas retorna apenas uma única saída. Esses valores devem ser tipos predefinidos por numpy.

Código de exemplo

Neste exemplo, criaremos uma função simples que pega uma lista de valores, adiciona-os e retorna a soma. Para demonstrar o poder da GPU, vamos executar uma dessas funções na CPU e outra na GPU e exibir os tempos. O código documentado está abaixo:

importar numpy como np de timeit importar default_timer como cronômetro de numba importar vetorizar # Este deve ser um valor substancialmente alto. Na minha máquina de teste, isso levou # 33 segundos para ser executado por meio da CPU e pouco mais de 3 segundos na GPU. NUM_ELEMENTS = 100000000 # Esta é a versão da CPU. def vector_add_cpu (a, b): c = np.zeros (NUM_ELEMENTS, dtype = np.float32) para i no intervalo (NUM_ELEMENTS): c [i] = a [i] + b [i] return c # Esta é a versão da GPU. Observe o decorador @vectorize. Isso diz a # numba para transformar isso em uma função vetorizada de GPU. @vectorize (["float32 (float32, float32)"], target = "cuda") def vector_add_gpu (a, b): return a + b; def main (): a_source = np.uns (NUM_ELEMENTS, dtype = np.float32) b_source = np.uns (NUM_ELEMENTS, dtype = np.float32) # Hora da função de CPU start = timer () vector_add_cpu (a_source, b_source) vector_add_cpu_time = timer () - start # Hora da função GPU start = timer () vector_add_gpu (a_source, b_source) vector_add_gpu_time = timer () - start # Relatório times print ("a função da CPU levou% f segundos."% vector_add_cpu_time) print (" A função GPU levou% f segundos."% vector_add_gpu_time) retorna 0 se __name__ ==" __main__ ": main () 

Para executar o exemplo, digite:

python gpu-example.py

NOTA: Se você tiver problemas ao executar seu programa, tente usar “conda install accelerate”.

Como você pode ver, a versão da CPU é consideravelmente mais lenta.

Se não, então suas iterações são muito pequenas. Ajuste os NUM_ELEMENTS para um valor maior (no meu, a marca de equilíbrio parecia estar em torno de 100 milhões). Isso ocorre porque a configuração da GPU leva um tempo pequeno, mas perceptível, portanto, para fazer a operação valer a pena, é necessária uma carga de trabalho maior. Depois de aumentá-lo acima do limite de sua máquina, você notará melhorias substanciais de desempenho da versão da GPU em relação à versão da CPU.

Conclusão

Espero que você tenha gostado de nossa introdução básica à programação de GPU com Python. Embora o exemplo acima seja trivial, ele fornece a estrutura de que você precisa para levar suas ideias ainda mais longe, utilizando o poder de sua GPU.