Get best of the week

GoLang und OpenCV (OpenVino && Cuda)

Guten Tag allerseits. Es gibt bereits viele Artikel über die Arbeit mit OpenCV on Go im Hub ( und im Internet ).

Der fertige Code ist sicherlich interessant, aber detailliertere Informationen zur Installation von Treibern müssen in Teilen gesammelt werden - ich werde versuchen, alle erforderlichen Gesten in einem Artikel zu kombinieren.

Bild


Ich habe einen Laptop mit Ubuntu 18.04 an Bord,

  • CPU: Intel
  • GPU: Intel / Nvidia

Nvidia und Intel versuchen sich gegenseitig zu schlagen, und ich werde versuchen, gleichzeitig OpenVino und Cuda auszunutzen.
Ich warne Sie sofort, um Cuda zu verwenden, benötigen Sie eine Mindest-Rechenkapazität (Version) 5.3, die Sie für Ihre Grafikkarte hier sehen können

Cuda


Ich habe Cuda 10.0 gewählt, damit ich auch Tensorflow verwenden kann.

Zuerst müssen Sie ein Paket mit developer.nvidia.com herunterladen (z. B. den

Bild

Set-Befehl runtime (local) )

sudo sh cuda_10.0.130_410.48_linux.run


cudNN


Link zu Paketen
Sie müssen die Version auswählen, die zu Cuda passt
Laden Sie cuDNN v7.5.0 (21. Februar 2019) für CUDA 10.0 herunter

Bild

Und laden Sie zwei Deb-Pakete herunter
cuDNN-Entwicklerbibliothek für Ubuntu18.04 (Deb)
cuDNN-Entwicklerbibliothek für Ubuntu18.04 (Deb)

Wenn Sie kein Konto unter https://developer.nvidia.com/ haben , werden Sie aufgefordert, die

Bild

Installation zu registrieren :

sudo dpkg -i libcudnn7-dev_7.5.0.56-1+cuda10.0_amd64.deb
sudo dpkg -i libcudnn7_7.5.0.56-1+cuda10.0_amd64.deb

Intel OpenCL-Treiber


Link zum Repository .

Installation:

wget https://github.com/intel/compute-runtime/releases/download/20.04.15428/intel-gmmlib_19.4.1_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/20.04.15428/intel-igc-core_1.0.3151_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/20.04.15428/intel-igc-opencl_1.0.3151_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/20.04.15428/intel-opencl_20.04.15428_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/20.04.15428/intel-ocloc_20.04.15428_amd64.deb

sudo dpkg -i *.deb

Opencv + OpenVino

Script (natürlich mit Krücken), das alles selbst sammelt.

run.sh
#!/bin/bash
git clone https://github.com/opencv/dldt -b 2019 && \
            (cd dldt/inference-engine && \
            git submodule init && \
            git submodule update --recursive && \
            ./install_dependencies.sh && \
            mv -f thirdparty/clDNN/common/intel_ocl_icd/6.3/linux/Release thirdparty/clDNN/common/intel_ocl_icd/6.3/linux/RELEASE && \
            mkdir -p build && \
            cd build && \
            cmake -D CMAKE_BUILD_TYPE=RELEASE \
                  -D CMAKE_INSTALL_PREFIX=/usr/local \
                  -D BUILD_SHARED_LIBS=ON \
                  -D ENABLE_TESTS=OFF \
                  -D ENABLE_VPU=ON \
                  -D ENABLE_MKL_DNN=ON \
                  -D ENABLE_CLDNN=ON .. && \
                  make -j $(nproc --all) && \
                  touch VERSION && \
                  mkdir -p src/ngraph && \
                  sudo cp -r ../bin/intel64/RELEASE/lib/* /usr/local/lib && \
                  cp thirdparty/ngraph/src/ngraph/version.hpp src/ngraph && \
                  sudo make install)

OPENCV_VERSION="4.2.0"

# install opencv
curl -Lo opencv.zip https://github.com/opencv/opencv/archive/${OPENCV_VERSION}.zip && \
            unzip -q opencv.zip && \
            curl -Lo opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/${OPENCV_VERSION}.zip && \
            unzip -q opencv_contrib.zip && \
            rm opencv.zip opencv_contrib.zip && \
            (cd opencv-${OPENCV_VERSION} && \
            mkdir build && cd build && \
            cmake -D CMAKE_BUILD_TYPE=RELEASE \
                  -D CMAKE_INSTALL_PREFIX=/usr/local \
                  -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-${OPENCV_VERSION}/modules \
                  -D InferenceEngine_DIR=../../../dldt/inference-engine/build \
                  -D WITH_JASPER=OFF \
                  -D BUILD_DOCS=OFF \
                  -D BUILD_EXAMPLES=OFF \
                  -D ENABLE_CXX11=ON \
                  -D WITH_INF_ENGINE=ON \
                  -D WITH_QT=OFF \
                  -D WITH_GTK=ON \
                  -D WITH_FFMPEG=OFF \
                  -D CUDA_ARCH_BIN=5.3,6.0,6.1,7.0,7.5 \
                  -D CUDA_ARCH_PTX=5.3 \
                  -D WITH_CUDA=ON \
                  -D WITH_CUDNN=ON \
                  -D OPENCV_DNN_CUDA=ON \
                  -D ENABLE_FAST_MATH=1 \
                  -D WITH_CUBLAS=1 \
                  -D WITH_TIFF=OFF \
                  -D WITH_WEBP=OFF \
                  -D WITH_QT=OFF \
                  -D WITH_PNG=OFF \
                  -D WITH_1394=OFF \
                  -D HAVE_OPENEXR=OFF \
                  -D BUILD_TESTS=OFF \
                  -D BUILD_PERF_TESTS=OFF \
                  -D BUILD_opencv_java=NO \
                  -D BUILD_opencv_python=NO \
                  -D BUILD_opencv_python2=NO \
                  -D BUILD_opencv_python3=NO \
                  -D BUILD_SHARED_LIBS=ON \
                  -D OPENCV_GENERATE_PKGCONFIG=ON .. && \
            make -j $(nproc --all) && \
            sudo make preinstall && sudo make install && sudo ldconfig )


Lassen Sie uns nun überprüfen, wie dies funktionieren wird!

Wir klonen uns den Quellcode:

git clone https://github.com/Danile71/go_realtime_object_recognition
cd go_realtime_object_recognition
go get -d
go build
./go_realtime_object_recognition

Die Videoerkennung funktioniert auf CPU, VulkanAPI und / oder Cuda.

Jetzt habe ich mehrere Pull-Anfragen gestellt
github.com/hybridgroup/gocv

um OpenVino + Cuda zu unterstützen, aber es ist nicht bekannt, wie lange sie zum Hauptzweig gehen werden, also machen wir einen kleinen Trick:

#!/bin/bash
cd $GOPATH/src/gocv.io/x/gocv
wget https://patch-diff.githubusercontent.com/raw/hybridgroup/gocv/pull/607.patch
wget https://patch-diff.githubusercontent.com/raw/hybridgroup/gocv/pull/609.patch
wget https://patch-diff.githubusercontent.com/raw/hybridgroup/gocv/pull/610.patch
wget https://patch-diff.githubusercontent.com/raw/hybridgroup/gocv/pull/612.patch

patch -p1 < 607.patch
patch -p1 < 609.patch
patch -p1 < 610.patch
patch -p1 < 612.patch

Damit können Sie gleichzeitig OpenVino / CPU / VulkanAPI / Cuda verwenden

go build -tags openvino
./go_realtime_object_recognition

Und um ein Gerät auszuwählen, ändern Sie

  • Zentralprozessor

    modelNet.SetPreferableBackend(gocv.NetBackendDefault)
modelNet.SetPreferableTarget(gocv.NetTargetCPU)

  • VulkanAPI

    modelNet.SetPreferableBackend(gocv.NetBackendVKCOM)
modelNet.SetPreferableTarget(gocv.NetTargetVulkan)

  • Cuda
    modelNet.SetPreferableBackend(gocv.NetBackendCUDA)
modelNet.SetPreferableTarget(gocv.NetTargetCUDA)

  • Intel GPU

    modelNet.SetPreferableBackend(gocv.NetBackendOpenVINO)
modelNet.SetPreferableTarget(gocv.NetTargetFP16)

  • Intel Neural Compute Stick 2
    modelNet.SetPreferableBackend(gocv.NetBackendOpenVINO)
modelNet.SetPreferableTarget(gocv.NetTargetVPU)


Hier ist ein weiteres kleines Beispiel mit Geschlechts- / Alters- / Emotionserkennung.

Und hier ist die Erkennung des "menschlichen" Objekts mit Cuda.

Wenn jemand interessiert ist und etwas nicht geklappt hat, schreibe,

ich helfe gerne :-) Chukchi ist kein Schriftsteller, aber ich habe es versucht.

upd.
Es gibt Zeiten, in denen Sie eine statische Binärdatei erstellen müssen. Ersetzen Sie dazu dldt und opencv in der Assembly
-D BUILD_SHARED_LIBS=ON

auf der
-D BUILD_SHARED_LIBS=OFF

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

More articles:


All Articles