Geekly articles weekly

Build Caffe en Google Colaboratory: Tarjeta gráfica gratuita en la nube

Google Colaboratory es un servicio en la nube recientemente lanzado destinado a simplificar la investigación en aprendizaje automático y aprendizaje profundo. Con el Colaboratorio, puede obtener acceso remoto a una máquina con una tarjeta de video conectada, y es completamente gratis, lo que simplifica enormemente la vida cuando tiene que entrenar redes neuronales profundas. Podemos decir que es un análogo de los documentos de Google para el Jupyter Notebook.

Colaboratory tiene Tensorflow preinstalado y casi todas las bibliotecas de Python necesarias para trabajar. Si falta un paquete, se instala fácilmente sobre la pip través de pip o apt-get . Pero, ¿qué sucede si necesita construir un proyecto desde la fuente y conectarse a la GPU? Resulta que esto puede no ser tan simple que descubrí durante la compilación de SSD-Caffe . En esta publicación, daré una breve descripción del Colaboratorio, describiré las dificultades encontradas y cómo resolverlas, y proporcionaré algunos trucos útiles.

Todo el código está disponible en mi cuaderno de colaboración .


Brevemente sobre Colaboratorio


Hablando en términos generales, Colaboratory le permite ejecutar Jupyter Notebook en una máquina remota. Los archivos de colaboración son "laptops" .ipynb comunes y se almacenan en el disco de Google. También hay un conjunto de funciones que le permite cargar archivos desde una máquina remota al disco de Google y viceversa. También puede compartir estos archivos con otros, puede escribir comentarios sobre ellos, como en los documentos de Google.

En el Colaboratorio, puede usar la GPU, es decir, el Tesla K80. Para hacer esto, conéctelo en la configuración: Tiempo de ejecución  rightarrowCambiar tipo de tiempo de ejecución  rightarrowAcelerador de hardware. Vale la pena señalar que las GPU no siempre están disponibles, y luego el Colaboratorio ofrecerá arrancar la máquina sin ella.

Parece que no se puede iniciar nada excepto el propio Jupyter Notebook, pero hay acceso indirecto al terminal: para esto, debe agregar un signo de exclamación antes del comando del terminal, por ejemplo !mkdir images . En general, podemos suponer que estamos tratando con una máquina ordinaria perfecta en la que está instalado Ubuntu 17.10 (en el momento de la escritura), pero conectado de forma remota. Se deduce que todo lo que se puede hacer a través del terminal (no de forma interactiva) se puede hacer en él, incluyendo:

  • clonar repositorios usando git clone ,
  • cargar datos usando wget (por cierto, incluso los archivos grandes se cargan casi instantáneamente desde un disco de Google),
  • use make (y probablemente cmake )
  • instalar herramientas y bibliotecas usando apt-get y pip

Algunos comentarios más sobre el Colaboratorio:

  • Parece que el usuario tiene acceso ilimitado a todos los archivos del sistema (cualquier comando debe escribirse sin sudo );
  • El estado terminal no se transfiere entre los equipos, incluso si están en la misma celda (por ejemplo, cd dir si es necesario, deberá escribir al comienzo de cada comando);
  • Si se desconecta del Colaboratorio durante mucho tiempo, se borrarán todos los cambios en la máquina virtual, incluidos todos los paquetes instalados y los archivos descargados, por lo tanto, se recomienda que la instalación de los paquetes se incluya en el Jupyter Notebook;
  • Después de 12 horas de uso continuo, la máquina se apaga automáticamente, pero luego se puede reiniciar (en teoría, en la práctica, la GPU puede no estar disponible).

SSD-Caffe Build


Quería probar el Single Shot Detector (SSD) , es decir, su implementación Caffe en Google Colaboratory, pero para esto, el proyecto necesitaba ser ensamblado desde la fuente.

Por cierto, si alguna versión de Caffe es adecuada para usted, hay una manera mucho más fácil (incluso funciona, aunque no he intentado ejecutar nada):

 !apt install caffe-cuda

Ensamblar SSD-Caffe desde el origen es una búsqueda bastante larga de varios pasos, que solo se puede hacer con muletas.

Paso 1: instalación de dependencias

Aquí debemos descargar todas las dependencias de Caffe usando apt . Sin embargo, antes de hacer esto, debe permitir que apt descargue el código fuente de la dependencia. La guía de instalación de Caffe dice que esto requiere una "línea deb-src en el archivo sources.list". Desafortunadamente, no hay detalles allí, así que simplemente descomenté todas las líneas deb-src en el archivo /etc/apt/sources.list :

 with open('/etc/apt/sources.list') as f: txt = f.read() with open('/etc/apt/sources.list', 'w') as f: f.write(txt.replace('# deb-src','deb-src'))

Y funcionó. Solo queda descargar las dependencias:

 !apt update !apt build-dep caffe-cuda

Paso 2: necesita otro compilador

Aquí el problema es este: g++-7 , que es el predeterminado por defecto, es por alguna razón incompatible con el compilador nvcc CUDA, por lo que debe usar algo más. Descargué g++-5 y lo convertí en el compilador predeterminado:

 !apt install g++-5 !update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 20 !update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 20

Paso 3: tienes que construir impulso

Si intenta construir Caffe en esta etapa, surgirán problemas cuando intente conectar boost, porque fue compilado por otro compilador, por lo que debe descargar sus fuentes y también compilar usando g++-5 ( más en el sitio web de boost ):

 !wget https://dl.bintray.com/boostorg/release/1.67.0/source/boost_1_67_0.tar.bz2 !tar --bzip2 -xf boost_1_67_0.tar.bz2 !cd boost_1_67_0 && ./bootstrap.sh --exec-prefix=/usr/local --with-libraries=system,filesystem,regex,thread,python --with-python-version=2.7 --with-python-root=/usr !cd boost_1_67_0 && ./b2 install

Paso 4: Configurar Makefile

Clone Caffe con GitHub:

 !git clone https://github.com/weiliu89/caffe.git && cd caffe && git checkout ssd

Y cambiamos los campos necesarios en Makefile.config: cambié la ruta a CUDA, cambié la opción BLAS, cambié la versión de OpenCV a un tercero, agregué una capa de Python y también agregué todas las rutas a las bibliotecas que se instalaron, pero por alguna razón no se encontraron (todo esto es conveniente) hecho usando Python):

 with open('caffe/Makefile.config.example') as f: config = f.read() comment = ['CUDA_DIR := /usr/local/cuda', 'BLAS := open'] uncomment = ['# CUDA_DIR := /usr', '# BLAS := atlas', '# OPENCV_VERSION := 3', '# WITH_PYTHON_LAYER := 1'] # replace = [('INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include', 'INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include /usr/include/hdf5/serial /usr/local/lib/python2.7/dist-packages/numpy/core/include/'), ('LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib', 'LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu/hdf5/serial')] for c in uncomment: config = config.replace(c, c[2:]) for c in comment: config = config.replace(c, '# '+c) for c1,c2 in replace: config = config.replace(c1, c2) with open('caffe/Makefile.config', 'w') as f: f.write(config)

Además, en el Makefile en sí, tuve que reemplazar todas las etiquetas -isystem con -I : ambas son responsables de encontrar los encabezados, pero se procesan de manera un poco diferente, y sin este problema de reemplazo ya ocurrió cuando stdlib estaba conectado ( más detalles aquí ):

 with open('caffe/Makefile') as f: mfile = f.read() with open('caffe/Makefile', 'w') as f: f.write(mfile.replace('-isystem','-I'))

Paso 5: construir

c++config.h una última muleta: para corregir el c++config.h , de lo contrario, hay problemas con los tipos nan ( más ):

 with open('/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h') as f: txt = f.read() with open('/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h', 'w') as f: f.write(txt.replace('/* #undef _GLIBCXX_USE_C99_MATH */', '/* #undef _GLIBCXX_USE_C99_MATH */\n#define _GLIBCXX_USE_C99_MATH 1'))

Ahora, de hecho, puedes construir Caffe:

 !cd caffe && make -j8 && make pycaffe && make test -j8 && make distribute !echo /usr/local/lib >> /etc/ld.so.conf && ldconfig !echo /content/caffe/distribute/lib >> /etc/ld.so.conf && ldconfig

Las dos últimas líneas agregan las rutas de la biblioteca, a saber, boost y Caffe.

Ahora se puede usar Caffe (solo necesita especificar la ruta en PYTHONPATH):

 import sys caffe_path = !cd caffe/python && pwd sys.path.insert(0, caffe_path[0]) import caffe

Para probarlo, probé el proyecto Mobilenet-SSD : el código también está en mi cuaderno de colaboración .

En particular, medí el tiempo de predicción para una imagen, y la aceleración en la GPU fue de aproximadamente 3.8.

Bonus: algunos trucos útiles


Hay un gran tutorial sobre Medium en Google Colaboratory. También en el propio Colaboratorio hay archivos con ejemplos de casi todo lo que puede ser necesario.

Monte un disco de Google en el sistema de archivos de una máquina virtual:

 !apt-get install -y -qq software-properties-common python-software-properties module-init-tools !add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null !apt-get update -qq 2>&1 > /dev/null !apt-get -y install -qq google-drive-ocamlfuse fuse from google.colab import auth auth.authenticate_user() from oauth2client.client import GoogleCredentials creds = GoogleCredentials.get_application_default() import getpass !google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL vcode = getpass.getpass() !echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}

Este código devolverá el enlace y dará una ventana de entrada. Debe seguir el enlace, copiar el código e ingresarlo en la ventana. Por alguna razón, tengo que hacer esto dos veces. Siguiente:

 !mkdir -p drive !google-drive-ocamlfuse drive

Después de eso, puede usar su disco de Google como un directorio normal. Además, todos los cambios en este directorio se sincronizan automáticamente con Google-drive.

Instalación de Keras :

 !pip install -q keras import keras

Instale PyTorch :

 from os import path from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag()) accelerator = 'cu80' if path.exists('/opt/bin/nvidia-smi') else 'cpu' !pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.3.0.post4-{platform}-linux_x86_64.whl torchvision import torch

Cambiar directorio de trabajo:

 import os os.chdir("/path/to/wdir")

Borre todos los cambios y reinicie la máquina:

 !kill -9 -1

Suba el archivo a la máquina local:

 from google.colab import files files.download('file.ext')

Obtenga el diccionario de los archivos cargados en el disco de Google:

 from google.colab import files uploaded = files.upload()

Salida de comando de terminal de silencio (redirigir a variable):

 lines_list = !pwd

En general, Google Colaboratory brinda una buena oportunidad para realizar capacitación de redes neuronales en la nube. Es cierto que esto puede no ser suficiente para cuadrículas muy grandes. Otra ventaja es la capacidad de ejecutar código independientemente del sistema operativo local (que es bueno para la reproducibilidad), y también trabajar juntos en el mismo proyecto. Como captura, la GPU puede no estar disponible, incluso durante mucho tiempo.

Source: https://habr.com/ru/post/es413229/

More articles:


All Articles