Geekly articles weekly

Crie o Caffe no Google Colaboratory: placa gráfica gratuita na nuvem

O Google Colaboratory é um serviço de nuvem lançado recentemente, que visa simplificar a pesquisa em aprendizado de máquina e aprendizado profundo. Usando o Colaboratory, você pode obter acesso remoto a uma máquina com uma placa de vídeo conectada e é totalmente gratuito, o que simplifica bastante a vida quando você precisa treinar redes neurais profundas. Podemos dizer que é um análogo dos documentos do Google para o Jupyter Notebook.

O Colaboratory possui o Tensorflow pré- instalado e quase todas as bibliotecas Python necessárias para o trabalho. Se um pacote estiver faltando, ele é facilmente instalado em qualquer lugar através do pip ou apt-get . Mas e se você precisar criar um projeto a partir da fonte e se conectar à GPU? Acontece que isso pode não ser tão simples que eu descobri durante a construção do SSD-Caffe . Nesta publicação, darei uma breve descrição do Colaboratório, descreverei as dificuldades encontradas e como resolvê-las, além de fornecer alguns truques úteis.

Todo o código está disponível no meu Caderno Colaborativo .


Brevemente sobre Colaboratory


Grosso modo, o Colaboratory permite executar o Jupyter Notebook em uma máquina remota. Os arquivos colaborativos são "laptops" .ipynb comuns e são armazenados no disco do Google. Há também um conjunto de funções que permite fazer upload de arquivos de uma máquina remota para o disco do Google e vice-versa. Você também pode compartilhar esses arquivos com outras pessoas, escrever comentários sobre eles, como nos documentos do Google.

No Colaboratório, você pode usar a GPU, ou seja, o Tesla K80. Para fazer isso, conecte-o nas configurações: Tempo de execução  rightarrowAlterar o tipo de tempo de execução  rightarrowAcelerador de hardware. Vale ressaltar que nem sempre as GPUs estão disponíveis e, em seguida, o Colaboratory oferecerá iniciar a máquina sem ela.

Parece que nada pode ser iniciado, exceto o próprio Jupyter Notebook, mas há acesso indireto ao terminal: para isso, é necessário adicionar um ponto de exclamação na frente do comando do terminal, por exemplo !mkdir images . Em geral, podemos assumir que estamos lidando com uma máquina comum perfeita na qual o Ubuntu 17.10 está instalado (no momento da escrita), mas conectado remotamente. Daqui resulta que tudo o que pode ser feito através do terminal (não interativamente) pode ser feito nele, incluindo:

  • clonar repositórios usando git clone ,
  • carregar dados usando o wget (a propósito, até arquivos grandes são carregados quase instantaneamente em um disco do Google),
  • use make (e provavelmente cmake )
  • instalar ferramentas e bibliotecas usando o apt-get e o pip

Mais alguns comentários sobre o Colaboratory:

  • Parece que o usuário tem acesso ilimitado a todos os arquivos do sistema (qualquer comando precisa ser escrito sem o sudo );
  • O estado do terminal não é transferido entre equipes, mesmo que estejam na mesma célula (por exemplo, cd dir se necessário, você precisará escrever no início de cada comando);
  • Se você se desconectar do Colaboratory por um longo tempo, todas as alterações na máquina virtual serão apagadas, incluindo todos os pacotes instalados e arquivos baixados; portanto, é recomendável que a instalação dos pacotes seja incluída no Jupyter Notebook;
  • Após 12 horas de uso contínuo, a máquina desliga automaticamente, mas pode ser reiniciada (em teoria, na prática, a GPU pode não estar disponível).

Construção SSD-Caffe


Eu queria experimentar o Single Shot Detector (SSD) , ou seja, sua implementação Caffe no Google Colaboratory, mas, para isso, o projeto precisava ser montado a partir da fonte.

A propósito, se qualquer versão do Caffe é adequada para você, existe uma maneira muito mais fácil (funciona mesmo, embora eu não tenha tentado executar nada):

 !apt install caffe-cuda

A montagem do SSD-Caffe a partir da fonte é uma busca bastante longa de várias etapas, o que só pode ser feito com muletas.

Etapa 1: instalando dependências

Aqui devemos baixar todas as dependências do Caffe usando o apt . No entanto, antes de fazer isso, você deve permitir que o apt download do código fonte da dependência. O guia de instalação do Caffe diz que isso requer uma "linha deb-src no arquivo sources.list". Infelizmente, não há detalhes lá, então apenas descomentei todas as linhas deb-src no arquivo /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'))

E funcionou. Resta apenas fazer o download das dependências:

 !apt update !apt build-dep caffe-cuda

Etapa 2: precisar de outro compilador

Aqui está o problema: g++-7 , que é o padrão por padrão, é, por algum motivo, incompatível com o compilador nvcc CUDA, portanto, você deve usar outra coisa. Eu baixei o g++-5 e fiz dele o compilador padrão:

 !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

Etapa 3: precisa criar impulso

Se você tentar criar o Caffe nesta fase, surgirão problemas quando você tentar conectar o boost, porque ele foi criado por outro compilador, então você precisa fazer o download de suas fontes e também construir usando o g++-5 ( mais no site do 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

Etapa 4: Configurar Makefile

Clone Caffe com GitHub:

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

E alteramos os campos necessários no Makefile.config - alterei o caminho para CUDA, alterei a opção BLAS, alterei a versão do OpenCV para um terceiro, adicionamos uma camada Python e também todos os caminhos para as bibliotecas instaladas, mas por algum motivo não foram encontrados (tudo isso é conveniente feito 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)

Além disso, no Makefile, eu tive que substituir todas as tags -isystem por -I : ambas são responsáveis ​​por encontrar os cabeçalhos, mas são processadas de maneira um pouco diferente e sem esses problemas de substituição já ocorreram quando o stdlib foi conectado ( mais detalhes aqui ):

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

Etapa 5: criar

Havia uma última muleta restante - para corrigir o c++config.h , caso contrário, há problemas com os tipos nan ( mais ):

 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'))

Agora, de fato, você pode criar o 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

As duas últimas linhas adicionam os caminhos da biblioteca, nomeadamente boost e Caffe.

Agora o Caffe pode ser usado (você só precisa especificar o caminho para ele no PYTHONPATH):

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

Para testá-lo, testei o projeto Mobilenet-SSD : o código também está no meu Caderno de Colaboração .

Em particular, medi o tempo de previsão de uma imagem e a aceleração na GPU foi de cerca de 3,8.

Bônus: alguns truques úteis


Há um ótimo tutorial sobre Medium no Google Colaboratory. Também no próprio Colaboratório há arquivos com exemplos de quase tudo o que pode ser necessário.

Monte um disco do Google no sistema de arquivos de uma 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 retornará o link e fornecerá uma janela de entrada. Você precisa seguir o link, copiar o código e inseri-lo na janela. Por alguma razão, tenho que fazer isso duas vezes. Seguinte:

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

Depois disso, você pode usar seu disco do Google como um diretório regular. Além disso, todas as alterações neste diretório são sincronizadas automaticamente com o Google-drive.

Instalação Keras :

 !pip install -q keras import keras

Instale o 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

Alterar diretório de trabalho:

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

Apague todas as alterações e reinicie a máquina:

 !kill -9 -1

Faça o upload do arquivo para a máquina local:

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

Obtenha o dicionário dos arquivos enviados para o disco do Google:

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

Silenciar a saída do comando do terminal (redirecionar para variável):

 lines_list = !pwd

Em geral, o Google Colaboratory oferece uma boa oportunidade para realizar o treinamento de redes neurais na nuvem. É verdade que isso pode não ser suficiente para grades muito grandes. Outra vantagem é a capacidade de executar código independentemente do sistema operacional local (o que é bom para a reprodutibilidade) e também trabalhar juntos no mesmo projeto. Como uma captura, a GPU pode não estar disponível, inclusive por um longo tempo.

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

More articles:


All Articles