Programação de GPU com Python
Requisitos
Para este exercício, você precisará de uma máquina física com Linux e uma GPU baseada na NVIDIA, ou lançará uma instância baseada em GPU no Amazon Web Services. Deve funcionar bem, mas se você optar por usar uma máquina física, precisará garantir que os drivers proprietários da NVIDIA instalem, consulte as instruções: https: // linuxhint.com/install-nvidia-drivers-linux
Você também precisará do kit de ferramentas CUDA instalado. Este exemplo usa o Ubuntu 16.04 LTS especificamente, mas há downloads disponíveis para a maioria das principais distribuições Linux no seguinte URL: https: // desenvolvedor.nvidia.com/cuda-downloads
Eu prefiro o .Download baseado em Deb, e esses exemplos assumirão que você escolheu essa rota. O arquivo que você baixar é um .Pacote Deb, mas não tem um .Extensão do Deb, tão renomeando -o para ter um .Deb no final dele útil. Então você o instala com:
sudo dpkg -i package -name.Deb
Se você for solicitado sobre a instalação de uma tecla GPG, siga as instruções dadas para fazê -lo.
Agora você precisará instalar o próprio pacote CUDA. Para fazer isso, corra:
Atualização de sudo apt-get
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, recomendo a reinicialização para garantir que todos os módulos sejam adequadamente recarregados.
Em seguida, você precisará da distribuição do Anaconda Python. Você pode baixar isso 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 menor)
O local de instalação padrão deve estar bem e, neste tutorial, nós o usaremos. Por padrão, ele é instalado para ~/anaconda3
No final da instalação, você será solicitado a decidir se deseja adicionar Anaconda ao seu caminho. Responda sim aqui para facilitar a execução dos comandos necessários. Para garantir que essa alteração ocorra, depois que o instalador terminar completamente, faça logon e faça o login novamente na sua conta.
Mais informações sobre a instalação do Anaconda: https: // linuxhint.com/install-anaconda-python-on-ubuntu/
Finalmente precisaremos instalar numba. Numba usa o compilador LLVM para compilar o código Python para a máquina. Isso não apenas aprimora o desempenho do código Python regular, mas também fornece a cola necessária para enviar instruções à GPU em forma binária. Para fazer isso, corra:
CONDA Instale o numba
Limitações e benefícios da programação da 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 consideravelmente diferente de uma CPU padrão em um computador.
As CPUs lidam com muitas entradas e saídas diferentes e têm uma ampla 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, manusear anéis de proteção, segmentar 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 cegamente rápida. Para conseguir isso, eles esperam um estado mais uniforme de entrada e saída. Especializando -se em funções escalares. Uma função escalar leva uma ou mais entradas, mas retorna apenas uma 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, os adiciona e retorna a soma. Para demonstrar o poder da GPU, executaremos uma dessas funções na CPU e uma na GPU e exibiremos os tempos. O código documentado está abaixo:
importar numpy como npdo timeit importar default_timer como temporizador
De Numba importar vetorize
# Isso deve ser um valor substancialmente alto. Na minha máquina de teste, isso levou
# 33 segundos para executar pela CPU e pouco mais de 3 segundos na GPU.
NUM_ELEMENTS = 100000000
# Esta é a versão da CPU.
DEFT 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]
retornar c
# Esta é a versão da GPU. Observe o decorador @vectorize. Isso diz
# numba para transformar isso em uma função vetorizada de GPU.
@Vectorize (["float32 (float32, float32)"], Target = 'Cuda')
DEFT Vector_add_gpu (a, b):
retornar 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 da CPU
start = timer ()
vetor_add_cpu (a_source, b_source)
vetor_add_cpu_time = timer () - Iniciar
# Hora da função GPU
start = timer ()
vetor_add_gpu (a_source, b_source)
vetor_add_gpu_time = timer () - Iniciar
# Tempos de relatório
print ("A função da CPU levou %f segundos." % vetor_add_cpu_time)
print ("A função da GPU levou %f segundos." % vetor_add_gpu_time)
retornar 0
Se __name__ == "__main__":
principal()
Para executar o exemplo, digite:
Exemplo de Python GPU.py
NOTA: Se você tiver problemas ao executar seu programa, tente usar “A aceleração da instalação do CONDA”.
Como você pode ver, a versão da CPU funciona consideravelmente mais lenta.
Se não, então suas iterações são muito pequenas. Ajuste os números para um valor maior (na mina, a marca de equilíbrio parecia ser de cerca de 100 milhões). Isso ocorre porque a configuração da GPU leva uma quantidade pequena, mas perceptível. Depois de elevá -lo acima do limite da sua máquina, você notará melhorias substanciais de desempenho da versão da GPU na versão da CPU.
Conclusão
Espero que você tenha gostado da nossa introdução básica na programação da GPU com Python. Embora o exemplo acima seja trivial, ele fornece a estrutura necessária para levar suas idéias ainda mais utilizando o poder da sua GPU.