👾 🙆🏼 👨🏾‍⚖️ GoLang e OpenCV (OpenVino e& Cuda) 🐒 🧣 ⌛️

Bom Dia a todos. Já existem muitos artigos sobre como trabalhar com o OpenCV on Go no hub ( ~~e de fato na Internet~~ ).

O código pronto é certamente interessante, mas informações mais detalhadas sobre a instalação de drivers devem ser coletadas em pedaços - tentarei combinar todos os gestos necessários em um artigo.

Eu tenho um laptop com o Ubuntu 18.04 a bordo,

CPU: Intel
GPU: Intel / Nvidia

A Nvidia e a Intel estão tentando se derrotar, e tentarei tirar proveito do OpenVino e Cuda ao mesmo tempo.

Eu te aviso imediatamente, para usar o Cuda, você precisa de um recurso mínimo de Compute (versão) 5.3, você pode ver aqui sua placa de vídeo

Cuda

Eu escolhi o Cuda 10.0 para poder usar o Tensorflow também.

Primeiro, você precisa baixar um pacote com developer.nvidia.com (como o tempo de execução (local) )

imagem

Comando Set

sudo sh cuda_10.0.130_410.48_linux.run

cudNN

Link para pacotes
Você precisa selecionar a versão que corresponde ao Cuda, ou seja,

Faça o download do cuDNN v7.5.0 (21 de fevereiro de 2019), para CUDA 10.0

E baixe dois pacotes deb

Biblioteca do desenvolvedor cuDNN para Ubuntu18.04 (Deb)
Biblioteca do desenvolvedor cuDNN para Ubuntu18.04 (Deb)

Se você não possui uma conta https://developer.nvidia.com/ , você será solicitado a registrar a

imagem

instalação:

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

Driver Intel OpenCL

Link para o repositório .

Instalação:

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

Script Opencv + OpenVino (naturalmente com muletas), que coletará tudo sozinho.

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 )

Agora vamos verificar como isso vai funcionar!

Nós nos clonamos o código fonte:

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

O reconhecimento de vídeo funcionará em CPU, VulkanAPI e / ou Cuda.

Agora eu fiz várias solicitações pull

github.com/hybridgroup/gocv

para oferecer suporte ao OpenVino + Cuda, mas não se sabe quanto tempo eles irão para o ramo principal, então vamos fazer um pequeno truque:

#!/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 você possa usar o OpenVino / CPU / VulkanAPI / Cuda ao mesmo tempo

go build -tags openvino
./go_realtime_object_recognition

E para selecionar um dispositivo, altere

CPU

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)

Aqui está outro pequeno exemplo com reconhecimento de gênero / idade / emoção.

E então o reconhecimento do objeto "humano" usando Cuda.

Se alguém estiver interessado e algo não der certo, escreva,

terei prazer em ajudar :-) Chukchi não é escritor, mas tentei.

upd.
Há momentos em que você precisa criar um binário estático; para isso, substitua dldt e opencv na montagem

-D BUILD_SHARED_LIBS=ON

-D BUILD_SHARED_LIBS=OFF

GoLang e OpenCV (OpenVino e& Cuda)

Cuda

cudNN

Driver Intel OpenCL

More articles: