Erstellen Sie Caffe bei Google Colaboratory: Kostenlose Grafikkarte in der Cloud

    Google Colaboratory ist ein neuer Cloud-Dienst, der die Forschung im Bereich maschinelles Lernen und Deep Learning vereinfachen soll. Mit dem Colaboratory können Sie per Fernzugriff auf eine Maschine mit angeschlossener Grafikkarte zugreifen, und dies ist völlig kostenlos, was das Leben beim Trainieren tiefer neuronaler Netze erheblich vereinfacht. Wir können sagen, dass es sich um ein Analogon zu Google-Dokumenten für das Jupyter Notebook handelt.

    In Colaboratory sind Tensorflow und fast alle für die Arbeit erforderlichen Python-Bibliotheken vorinstalliert . Wenn ein Paket fehlt, kann es einfach unterwegs pipoder installiert werdenapt-get. Aber was ist, wenn Sie ein Projekt aus dem Quellcode erstellen und eine Verbindung zur GPU herstellen müssen? Es stellt sich heraus, dass dies möglicherweise nicht so einfach ist, wie ich beim Erstellen von SSD-Caffe herausgefunden habe . In dieser Veröffentlichung werde ich eine kurze Beschreibung des Kollaboratoriums geben, die aufgetretenen Schwierigkeiten beschreiben und erläutern, wie sie gelöst werden können, sowie einige nützliche Tricks nennen.

    Der gesamte Code ist in meinem Colaboratory Notebook verfügbar .


    Kurz über Colaboratory


    Grob gesagt können Sie mit Colaboratory Jupyter Notebook auf einem Remotecomputer ausführen. Kollaborative Dateien sind gewöhnliche .ipynb "Laptops" und werden auf der Google-Festplatte gespeichert. Es gibt auch eine Reihe von Funktionen, mit denen Sie Dateien von einem Remote-Computer auf die Google-Festplatte und umgekehrt herunterladen können. Sie können diese Dateien auch für andere freigeben und Kommentare dazu verfassen, wie in Google-Dokumenten.

    Im Colaboratory können Sie die GPU verwenden, nämlich den Tesla K80. Dazu verbinden Sie es in den Einstellungen: Runtime$ \ rightarrow $Laufzeittyp ändern$ \ rightarrow $Hardware-Beschleuniger. Es ist erwähnenswert, dass GPUs nicht immer verfügbar sind, und das Labor bietet dann an, die Maschine ohne sie zu starten.

    Es scheint, dass nichts außer dem Jupyter Notebook selbst gestartet werden kann, aber es gibt einen indirekten Zugriff auf das Terminal: Dazu müssen Sie beispielsweise ein Ausrufezeichen vor dem Terminalbefehl einfügen !mkdir images. Im Allgemeinen können wir davon ausgehen, dass es sich um eine perfekte normale Maschine handelt, auf der Ubuntu 17.10 installiert ist (zum Zeitpunkt des Schreibens), die jedoch remote verbunden ist. Daraus folgt, dass alles, was über das Terminal (nicht im interaktiven Modus) ausgeführt werden kann, ausgeführt werden kann, einschließlich:

    • Klon-Repositorys mit git clone,
    • Hochladen von Daten mit wget(übrigens werden auch große Dateien fast sofort von einer Google-Festplatte geladen),
    • verwenden make(und höchstwahrscheinlich cmake)
    • Installieren Sie Tools und Bibliotheken mit apt-getundpip

    Noch ein paar Kommentare zum Colaboratory:

    • Es scheint, dass der Benutzer uneingeschränkten Zugriff auf alle Dateien im System hat (alle Befehle müssen ohne geschrieben werden sudo).
    • Der Terminalstatus wird nicht zwischen Teams übertragen, auch wenn sie sich in derselben Zelle befinden ( cd dirSie müssen beispielsweise bei Bedarf zu Beginn jedes Befehls schreiben).
    • Wenn Sie für längere Zeit die Verbindung zum Colaboratory trennen, werden alle Änderungen an der virtuellen Maschine gelöscht, einschließlich aller installierten Pakete und heruntergeladenen Dateien. Daher wird empfohlen, die Installation von Paketen in das Jupyter Notebook aufzunehmen.
    • Nach 12 Stunden Dauerbetrieb schaltet sich das Gerät automatisch aus, kann dann aber neu gestartet werden (theoretisch ist die GPU in der Praxis möglicherweise nicht verfügbar).

    SSD-Caffe Build


    Ich wollte den Single Shot Detector (SSD) ausprobieren , nämlich seine Caffe-Implementierung in Google Colaboratory, aber dafür musste das Projekt aus dem Quellcode zusammengestellt werden.

    Übrigens, wenn eine Version von Caffe zu Ihnen passt , gibt es einen viel einfacheren Weg (es funktioniert sogar, obwohl ich noch nicht versucht habe, etwas auszuführen):

    !apt install caffe-cuda

    Das Zusammenbauen von SSD-Caffe aus dem Quellcode ist eine ziemlich lange Aufgabe, die aus mehreren Schritten besteht und nur mit Krücken durchgeführt werden kann.

    Schritt 1: Abhängigkeiten installieren

    Hier müssen wir alle Abhängigkeiten für Caffe mit herunterladen apt. Zuvor müssen Sie jedoch das aptHerunterladen der Abhängigkeitsquelle zulassen . In der Caffe-Installationsanleitung heißt es, dass hierfür eine „deb-src-Zeile in der Datei sources.list“ erforderlich ist. Leider gibt es dort keine Details, so dass ich nur alle deb-srcZeilen in der Datei auskommentiert habe /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'))
    

    Und es hat funktioniert. Es bleiben nur die Abhängigkeiten herunterzuladen:

    
    !apt update
    !apt build-dep caffe-cuda
    

    Schritt 2: Sie benötigen einen anderen Compiler

    Hier ist das Problem: Dieser Compiler ist g++-7standardmäßig der Hauptcompiler. Aus irgendeinem Grund ist er nicht mit dem CUDA-Compiler kompatibel nvcc, sodass Sie etwas anderes verwenden müssen. Ich habe es heruntergeladen g++-5und zum Standard-Compiler gemacht:

    
    !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
    

    Schritt 3: zu sammeln Schub haben

    Wenn Sie in diesem Stadium zu sammeln Caffe versuchen, treten Probleme auf , wenn Sie eine Verbindung herstellen Schub versuchen, wie er einen anderen Compiler gesammelt, so dass er den Quellcode herunterladen müssen und auch Collect durch einen g++-5( mehr Auftrieb Online ):

    
    !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
    

    Schritt 4: Konfigurieren Sie Makefile

    Clone Caffe mit GitHub:

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

    Und wir ändern die erforderlichen Felder in Makefile.config - Ich habe den Pfad zu CUDA geändert, die BLAS-Option geändert, die Version von OpenCV auf die dritte Version geändert, die Python-Ebene hinzugefügt und auch alle Pfade zu den installierten Bibliotheken hinzugefügt, aber aus irgendeinem Grund nicht gefunden (all dies ist praktisch fertig mit 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)
    

    Auch im Makefile selbst musste ich alle Tags -isystemdurch -IFolgendes ersetzen : Beide sind für das Finden der Header verantwortlich, werden jedoch ein wenig anders verarbeitet, und ohne dieses Ersetzen traten bereits Probleme beim Verbinden von stdlib auf ( hier wird näher darauf eingegangen ):

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

    Schritt 5: Zusammenbau Die

    letzte Krücke bleibt - um die Datei zu korrigieren c++config.h, sonst gibt es Probleme mit Nanotypen ( mehr ):

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

    Tatsächlich können Sie jetzt Caffe bauen:

    
    !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
    

    Die letzten beiden Zeilen fügen die Bibliothekspfade hinzu, nämlich boost und Caffe.

    Jetzt kann Caffe verwendet werden (Sie müssen nur den Pfad dazu in PYTHONPATH angeben):

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

    Zum Testen habe ich das Mobilenet-SSD- Projekt getestet : Der Code befindet sich auch in meinem Colaboratory Notebook .

    Insbesondere habe ich die Vorhersagezeit für ein Bild gemessen und die Beschleunigung auf der GPU betrug etwa 3,8.

    Bonus: einige nützliche Tricks


    Es gibt ein exzellentes Tutorial zu Medium bei Google Colaboratory . Auch im Labor selbst gibt es Dateien mit Beispielen für fast alles, was benötigt werden kann.

    Hängen Sie eine Google-Festplatte in das Dateisystem einer virtuellen Maschine ein:

    
    !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}
    

    Dieser Code gibt den Link zurück und gibt ein Eingabefenster. Sie müssen dem Link folgen, den Code kopieren und in das Fenster eingeben. Aus irgendeinem Grund muss ich das zweimal machen. Weiter:

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

    Danach können Sie Ihre Google-Festplatte als reguläres Verzeichnis verwenden. Außerdem werden alle Änderungen in diesem Verzeichnis automatisch mit Google-Drive synchronisiert. Keras-

    Installation :

    !pip install -q keras
    import keras
    

    Installieren Sie 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
    

    Arbeitsverzeichnis ändern:

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

    Löschen Sie alle Änderungen und starten Sie den Computer neu:

    !kill -9 -1

    Laden Sie die Datei auf den lokalen Computer hoch:

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

    Holen Sie sich das Wörterbuch aus Dateien, die auf Google Disk hochgeladen wurden:

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

    Stummschalten der Terminalbefehlsausgabe (Weiterleitung an Variable):

    lines_list = !pwd
    

    Im Allgemeinen bietet Google Colaboratory eine gute Möglichkeit zum Trainieren neuronaler Netzwerke in der Cloud. Für sehr große Gitter ist dies möglicherweise nicht ausreichend. Ein weiteres Plus ist die Möglichkeit, Code unabhängig vom lokalen Betriebssystem auszuführen (was für die Reproduzierbarkeit von Vorteil ist) und gleichzeitig am selben Projekt zusammenzuarbeiten. Ausnahmsweise ist die GPU auch für längere Zeit nicht verfügbar.

    Jetzt auch beliebt: