As maquinas que enxergam com visão computacional em
CPU, GPU e VPU

Autor: Alessandro de Oliveira Faria
cabelo@opensuse.org

   Tecnologia desde 1983
  • Autodidata
  • Pesquisador
  • Inventor
  • CTO OITI TECHNOLOGIES
  • Embaixador openSUSE America Latina
  • Membro do Conselho OWASP SP
  • Engenheiro Linux
  • Colaborador Mozillians
  • Desenvolvedor Innovator Intel
  • Contribuidor técnico oficial:
    • Viva o Linux
    • FOCA Linux
    • OWASP ZAP
    • OpenCV
    • Educatux
    • openSUSE
  • Mais de 90 palestras ministradas
    Visão Computacional
  • Demanda tempo real
  • Ruído
  • Ambiguidade
  • Custo Computacional
  • Evolução device

GPU não é CPU

A principal diferença, é a capacidade da CPU executar qualquer processamento, entretanto o processamento da CPU voltado aos gráfico é lento.

A GPU foi projetada inicialmente apenas para realizar o processamento gráfico. A GPU apresenta desempenho incomparável em cálculos de ponto flutuante.

A CPU concentra várias tarefas. Ele cuida de atividades simples, como o carregamento dos aplicativos (delegando ações para memória RAM, HD, chip de rede e placa de vídeo), até as situações mais complexas e também acesso a BIOS.

CPU menos núcleos e clocks mais elevados, GPU múltiplos núcleos e clocks menores (mas apresentam desempenho incrível para cálculos de ponto flutuante).

Programação Multinuclear

Programação multinuclear são alternativas às threads que proporcionam tempos de inicialização e encerramento mais rápidos, melhor distribuição de carga, melhor aproveitamento dos recursos disponíveis e um nível alto de abstração.


						for (int i = 0; i < 10000; ++i)
						 a[i] = f(i) + g(i);
	 
						tbb::parallel_for( 0, 10000, [&](int i) { a[i] = f(i) + g(i); } );
						

IPP/MKL

A biblioteca IPP (Primitivos de Performance Integrada) dos processadores Intel apresenta grandes ganhos de performance quando o problema proposto é processamento de imagem. Utiliza instruções dos processadores com AVX2 e SSE assim aumentando muito o desempenho.

Ja a biblioteca MKL,é uma excelente opção para processamento de imagens pelo simples motivo, foi criada para aplicações de alta performance computacional (HPC), é ideal para utilização de rotina matemáticas (Transformada de Fourier, Álgebra Linear, Calculo com Vetores e Matriz).

Plataforma Intel

SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2

Plataforma Power IBM

VSX

CUDA

A computação paralela é uma alternativa eficaz para agilizar enorme processamentos. Quando possuímos uma tarefa muito grande e complexa para ser resolvida, acabamos dividindo-a em afazeres menores e mais fáceis de serem terminados.

CUDA possibilita o uso de computação paralela.
A principal objetivo é tornar disponível os poderes da (GPU) para realizar algumas operações extremamente mais rápidas.

Ou seja, tornar capaz de trabalhar com aplicações não gráficas, como softwares de criptografia e simulações biológicas (Operações Aritméticas em Ponto Flutuante).

CuDNN : NVIDIA CUDA®
Deep Neural Network library

A cuDNN é uma biblioteca que utiliza a GPU para acelerar cálculos matemáticas nos aprendizados de Deep Learning, tornando assim possível o uso desta tecnologia por desenvolvedores nível mais alto em aplicações de aprendizado de maquina.


chmod +x cuda_8.0.61_375.26_linux.run 
./cuda_8.0.61_375.26_linux.run 

Using less to view the EULA.
Do you accept the previously read EULA?
accept/decline/quit: accept

Install NVIDIA Accelerated Driver for Linux-x86_64 375.26?
(y)es/(n)o/(q)uit: no

Install the CUDA 8.0 Toolkit?
(y)es/(n)o/(q)uit: yes

						

						Enter Toolkit Location
						 [ default is /usr/local/cuda-8.0 ]: 

						Do you want to install a symbolic link at /usr/local/cuda?
						(y)es/(n)o/(q)uit:  yes

						Install the CUDA 8.0 Samples?
						(y)es/(n)o/(q)uit: yes

						Enter CUDA Samples Location
						 [ default is /root ]: /dados/cuda

						Installing the CUDA Toolkit in /usr/local/cuda-8.0 …

						$  make
						

OpenCV 4.3.1 ou superior

OpenCV é a principal biblioteca de código aberto para a visão computacional, processamento de imagem e aprendizagem de máquina, disponibiliza a aceleração de calculo por GPU (util para em tempo real) e agora um novo módulo de dnn (deep learning).

Compilação


cmake -DCMAKE_BUILD_TYPE=Release \
      -DENABLE_VSX=ON \
      -DENABLE_SSE=0 \
      -DENABLE_SSE2=0 
						


cmake -DCMAKE_BUILD_TYPE=Release \
      -DWITH_IPP=ON \
      -DWITH_TBB=ON \
      -DWITH_CUDA=ON \
      -DENABLE_FAST_MATH=ON \
      -DCUDA_FAST_MATH=ON \
      -DWITH_CUBLAS=ON \
      -DENABLE_SSE=ON \
      -DENABLE_SSE2=ON \
      -DENABLE_SSE3=ON \
      -DENABLE_SSSE3=ON \
      -DENABLE_SSE41=ON \
      -DENABLE_SSE42=ON \
      -DENABLE_AVX=ON \
      -DENABLE_AVX2=ON \;
						

O acelerado crescimento deve-se as GPU e a grande massa de dados disponíveis na internet.

Machine Learning: Utiliza algoritmos para a coleta de dados, esta coleta deve ser efetuada por especialistas em visão computacional (para configurar os atributos relevantes da imagem). Durante o reconhecimento uma obstrução do objeto deriva em erros e diminuição da assertividade.

Deep Learning: Os algoritmos demandam muito menos preocupação com a coleta, bastando apenas informar os pixels (região o objeto, assim não exigindo preocupação com a extração dos dados da imagem).

O aprendizado acontece, recortando a imagem em uma pilha de pequenos pedaço, estes são enviados paras as camadas das redes neurais. E por fim o reconhecimento é baseado no peso total dos atributos da imagem obtido no processamento. Resultado é conseguir reconhecer um objeto obstruido.

Redes Neurais Convolucionais

Baseada na visão animal (córtex visual, filtro de Gabor), então as redes neurais convolucionais trabalham com os neurônios de entrada, nas sinapses obtemos os pesos aplicando uma função com o kernel convolucional, e então teremos os neurônios de saída que poder servir como propagação reversa ou não.

Caracteríticas

Extração, mapeamento das características, Subamostragem.
Irrelevante a posição, localiza a característica local dos pontos, robusto (rotação e obstrução).
Várias camadas de convolução, não linearidade max(0,x) obter esparcidade.

Yolo

YOLO (You only look once) é uma nova técnica de reconhecimento de objetos, e utiliza convolução para obter uma excelente performance.

Darknet Open Source /Neural Networks / C

Compilação


$ git clone https://github.com/pjreddie/darknet

$ vi Makefile
GPU=1
CUDNN=1
OPENCV=1
OPENMP=1

$ make
gcc -Iinclude/ -Isrc/ -DOPENCV `pkg-config --cflags opencv`  -DGPU -I/usr/local/cuda/include/ -DCUDNN  -Wall -Wno-unknown-pragmas -Wfatal-errors -fPIC -fopenmp -Ofast -DOPENCV -DGPU -DCUDNN -c ./src/gemm.c -o obj/gemm.o
gcc -Iinclude/ -Isrc/ -DOPENCV `pkg-config --cflags opencv`  -DGPU -I/usr/local/cuda/include/ -DCUDNN  -Wall -Wno-unknown-pragmas -Wfatal-errors -fPIC -fopenmp -Ofast -DOPENCV -DGPU -DCUDNN -c ./src/utils.c -o obj/utils.o

$ darknet detector demo cfg/coco.data cfg/yolo.cfg cfg/yolo.weights -c 2 -thresh .60
						

Aprendizado YOLO


    dw = 1./size[0]
    dh = 1./size[1]
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = (box[0] +(w/2.0)
    y = (box[2] +(h/2.0)
    x = x*dw
    w = w*dw
    y = y*dh
    h = h*dh

/dados/image/train.txt
    /dados/image/car1.jpg
/dados/label/car1.txt
    0 0.482422 0.650000 0.280469 0.652778    


						

YOLO e openCV

Efetuar o download da versão 3.4.0 ou superior :


$ cd [PATH-SOURCE-OPENCV]/opencv/samples/dnn/

$ g++ `pkg-config --cflags opencv` `pkg-config --libs opencv` \
       yolo_object_detection.cpp -o yolo_object_detection

$ ./yolo_object_detection -source=[PATH-TO-VIDEO]  \ 
               -cfg=[PATH-TO-DARKNET]/cfg/yolo.cfg \ 
             -model=[PATH-TO-DARKNET]/yolo.weights \ 
      -class_names=[PATH-TO-DARKNET]/data/coco.names
						
Mais informações em: https://docs.opencv.org/master/da/d9d/tutorial_dnn_yolo.html

Resultado







Obrigado!

Critícas e Sugestiões:
Alessandro de Oliveira Faria
cabelo@opensuse.org

Blog: https://assuntonerd.com.br


“Colaborar atrai amigos, competir atrai inimigos”
Start broadcast