Get best of the week

GoLang y OpenCV (OpenVino && Cuda)

Buen día a todos. Ya hay muchos artículos sobre cómo trabajar con OpenCV on Go en el hub ( y de hecho en Internet ).

El código final es ciertamente interesante, pero se debe recopilar información más detallada sobre la instalación de controladores: intentaré combinar todos los gestos necesarios en un solo artículo.

imagen


Tengo una computadora portátil con Ubuntu 18.04 a bordo,

  • CPU: Intel
  • GPU: Intel / Nvidia

Nvidia e Intel están tratando de vencerse, e intentaré aprovechar OpenVino y Cuda al mismo tiempo.
Te advierto de inmediato, para usar Cuda necesitas una capacidad mínima de cómputo (versión) 5.3, puedes ver tu tarjeta de video aquí

Cuda


Elegí Cuda 10.0 para poder usar Tensorflow también.

Primero debe descargar un paquete con developer.nvidia.com (como el

imagen

comando Set (local) de tiempo de ejecución )

sudo sh cuda_10.0.130_410.48_linux.run


cudNN


Enlace a paquetes
Debe seleccionar la versión que coincida con Cuda, es decir
Descargar cuDNN v7.5.0 (21 de febrero de 2019), para CUDA 10.0

imagen

Y descargue dos paquetes deb
CuDNN Developer Library para Ubuntu18.04 (Deb)
cuDNN Developer Library para Ubuntu18.04 (Deb)

Si no tiene una cuenta https://developer.nvidia.com/ , se le pedirá que registre la

imagen

instalación:

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

Controlador Intel OpenCL


Enlace al repositorio .

Instalación:

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 (naturalmente con muletas), que recogerá todo por sí mismo.

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 )


¡Ahora veamos cómo funcionará esto!

Nos clonamos el código fuente:

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

El reconocimiento de video funcionará en CPU, VulkanAPI y / o Cuda.

Ahora he realizado varias solicitudes de extracción en
github.com/hybridgroup/gocv

para admitir OpenVino + Cuda, pero no se sabe cuánto tiempo irán a la rama maestra, así que hagamos un pequeño truco:

#!/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

Para que pueda usar OpenVino / CPU / VulkanAPI / Cuda al mismo tiempo

go build -tags openvino
./go_realtime_object_recognition

Y para seleccionar un dispositivo, cambie

  • UPC

    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)

  • GPU Intel

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

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


Aquí hay otro pequeño ejemplo con reconocimiento de género / edad / emoción.

Y aquí hay un reconocimiento del objeto "humano" usando Cuda.

Si alguien está interesado y algo no funcionó, escriba,

estaré encantado de ayudarlo :-) Chukchi no es escritor, pero lo intenté.

upd
Hay momentos en los que necesita construir un binario estático; para esto, reemplace dldt y opencv en el ensamblado
-D BUILD_SHARED_LIBS=ON

sobre el
-D BUILD_SHARED_LIBS=OFF

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

More articles:


All Articles