Programación de GPU con Python

En este artículo, nos sumergiremos en la programación de GPU con Python. Usando la facilidad de Python, puede desbloquear la increíble potencia informática de la GPU de su tarjeta de video (unidad de procesamiento de gráficos). En este ejemplo, trabajaremos con la biblioteca CUDA de Nvidia.

Requisitos

Para este ejercicio, necesitará una máquina física con Linux y una GPU basada en NVIDIA, o lanzar una instancia basada en GPU en Amazon Web Services. O debería funcionar bien, pero si elige usar una máquina física, deberá asegurarse de tener instalados los controladores propietarios de NVIDIA, consulte Instrucciones: https: // Linuxhint.com/install-nvidia-drivers-linux

También necesitará el kit de herramientas CUDA instalado. Este ejemplo usa Ubuntu 16.04 LTS específicamente, pero hay descargas disponibles para la mayoría de las principales distribuciones de Linux en la siguiente URL: https: // desarrollador.nvidia.com/cuda-downloads

Prefiero el .descarga basada en deb, y estos ejemplos asumirán que eligió esa ruta. El archivo que descarga es un .paquete Deb pero no tiene un .Extensión de deb, así que renombra para tener un .Deb al final su útil. Luego lo instala con:

sudo dpkg -i nombre de paquete.debutante

Si se le solicita sobre la instalación de una tecla GPG, siga las instrucciones dadas para hacerlo.

Ahora necesitará instalar el paquete CUDA en sí. Para hacerlo, corre:

actualización de sudo apt-get
sudo apt -get instalación cuda -y

Esta parte puede tomar un tiempo, por lo que es posible que desee tomar una taza de café. Una vez terminado, recomiendo reiniciar para asegurarse de que todos los módulos se vuelvan a cargar correctamente.

A continuación, necesitarás la distribución de Anaconda Python. Puedes descargar eso aquí: https: // www.anaconda.com/descargar/#Linux

Tome la versión de 64 bits e instálela así:

SH Anaconda*.mierda

(La estrella en el comando anterior asegurará que el comando se ejecute independientemente de la versión menor)

La ubicación de instalación predeterminada debe estar bien, y en este tutorial, la usaremos. Por defecto, se instala a ~/anaconda3

Al final de la instalación, se le pedirá que decida si desea agregar Anaconda a su camino. Respuesta Sí aquí para facilitar la ejecución de los comandos necesarios. Para garantizar que este cambio tenga lugar, después de que el instalador termine por completo, inicie sesión, vuelva a iniciar sesión en su cuenta.

Más información sobre la instalación de Anaconda: https: // Linuxhint.com/install-Anaconda-Python-on-Ubuntu/

Finalmente necesitaremos instalar numba. Numba usa el compilador LLVM para compilar Python en el código de la máquina. Esto no solo mejora el rendimiento del código de pitón regular, sino que también proporciona el pegamento necesario para enviar instrucciones a la GPU en forma binaria. Para hacer esto, ejecute:

CondA instalar numba

---

Limitaciones y beneficios de la programación de GPU

Es tentador pensar que podemos convertir cualquier programa de Python en un programa basado en GPU, acelerando drásticamente su rendimiento. Sin embargo, la GPU en una tarjeta de video funciona de manera considerablemente diferente a una CPU estándar en una computadora.

Las CPU manejan muchas entradas y salidas diferentes y tienen una amplia variedad de instrucciones para tratar estas situaciones. También son responsables de acceder a la memoria, tratar el bus del sistema, el manejo de los anillos de protección, la segmentación y la funcionalidad de entrada/salida. Son multitarea extremos sin un enfoque específico.

Las GPU, por otro lado, están construidas para procesar funciones simples con velocidad cegadora y cegadora. Para lograr esto, esperan un estado de entrada y salida más uniforme. Especializándose en funciones escalar. Una función escalar toma una o más entradas, pero devuelve solo una salida. Estos valores deben ser predefinidos predefinidos por Numpy.

Código de ejemplo

En este ejemplo, crearemos una función simple que toma una lista de valores, los agrega y devuelve la suma. Para demostrar el poder de la GPU, ejecutaremos una de estas funciones en la CPU y otra en la GPU y mostraremos los tiempos. El código documentado está a continuación:

importar numpy como np
Desde Timeit Imports Default_Timer como temporizador
de numba importe vectorize
# Este debería ser un valor sustancialmente alto. En mi máquina de prueba, esto tomó
# 33 segundos para funcionar a través de la CPU y poco más de 3 segundos en la GPU.
Num_elements = 100000000
# Esta es la versión de CPU.
def vector_add_cpu (a, b):
C = NP.Zeros (num_elements, dtype = np.flotante32)
para i en el rango (num_elements):
c [i] = a [i] + b [i]
regreso C
# Esta es la versión de GPU. Tenga en cuenta el decorador @Vectorize. Esto dice
# numba para convertir esto en una función vectorizada de GPU.
@Vectorize (["Float32 (Float32, Float32)"], Target = 'CUDA')
def vector_add_gpu (a, b):
devolver a + b;
Def Main ()::
a_source = np.un (num_elements, dtype = np.flotante32)
b_source = np.un (num_elements, dtype = np.flotante32)
# Tiempo de la función CPU
start = timer ()
vector_add_cpu (a_source, b_source)
vector_add_cpu_time = timer () - iniciar
# Tiempo de la función GPU
start = timer ()
vector_add_gpu (a_source, b_source)
vector_add_gpu_time = timer () - iniciar
# TIEMPOS DE INFORME
imprimir ("La función de la CPU tomó %F segundos." % vector_add_cpu_time)
imprimir ("La función GPU tomó %F segundos." % vector_add_gpu_time)
regresar 0
Si __name__ == "__main__":
principal()

Para ejecutar el ejemplo, escriba:

Python GPU-Ejemplo.py

Nota: Si se encuentra con problemas al ejecutar su programa, intente usar "CondA Instalar acelerar".

Como puede ver, la versión de la CPU se ejecuta considerablemente más lenta.

Si no, entonces sus iteraciones son demasiado pequeñas. Ajuste el num_elements a un valor mayor (en el mío, la marca de equilibrio parecía ser de alrededor de 100 millones). Esto se debe a que la configuración de la GPU toma una cantidad de tiempo pequeña pero notable, por lo que para que la operación valga la pena, se necesita una mayor carga de trabajo. Una vez que lo suba por encima del umbral para su máquina, notará mejoras sustanciales de rendimiento de la versión de GPU a través de la versión de CPU.

Conclusión

Espero que hayas disfrutado de nuestra introducción básica en la programación de GPU con Python. Aunque el ejemplo anterior es trivial, proporciona el marco que necesita para llevar sus ideas más utilizando el poder de su GPU.