Inteligência Artificial

Prof. Me. Fernando Stela

fernando.stela@docente.unip.br
Visão Computacional
Algoritmos Supervisionados de Machine Learning

Redes Neurais para Visão Computacional

MNIST e Fashion MNIST com Python

Convolutional Neural Network (CNN)

YOLO e COCO Dataset

Algoritmos Supervisionados de Machine Learning
 Treinamento de Redes Neurais
FEATURES:

Atraso Menstrual Cólica Mamas Sensíveis Enjoo Sonolência

1 0 0 1 1

Revisão!

LABELS:

Grávida
1
 DATASET (Base de Treinamento / Histórico / Exemplos):
Para a rede neural acertar muito, deve existir correlação entre as features (entradas) e o label
(saída)
Exemplo Atraso Cólica Mamas Enjoo Sonolência Grávida
Menstrual Sensíveis
1 1 0 0 0 0 0
2 1 1 0 1 0 1
3 0 1 0 0 1 0
4 0 0 1 1 1 1 Revisão!
5 1 1 1 0 0 1
6 0 0 1 0 0 1
7 1 1 0 1 1 0
8 1 0 0 0 0 1
9 0 1 0 0 1 1
10 1 0 0 0 0 0

Features (train_x) Labels (train_y)

Treinamento de Redes Neurais

Também são chamados de: Classificadores (classsifiers) ou estimadores

(estimators)

São utilizados para prever a classe de um dado, e podem ser utilizados quando
dados rotulados (features) estão disponíveis (exemplos)

Os dados de entrada são chamados de features, X

Os dados de saída são chamados de labels, Y, target ou classe

O relacionamento (padrão) entre os features e labels é chamado de model

Algoritmos Supervisionados de Machine Learning

Antes do uso de Redes Neurais, os algoritmos mais utilizados para

detecção de objetos eram:
• HOG (Histogram of Oriented Gradients) utiliza histograma com
vetor de gradiente
• Haar Cascade: Também conhecido como algoritmo Viola-Jones,
implementado no OpenCV, utilizado para reconhecimento de
faces
• LBP (Local Binary Pattern) utilizado para detectar bordas, linhas,
pontos
As Redes Neurais se mostraram mais eficientes (maior acurácia)
Redes Neurais para Visão Computacional

⁻ 1966 - Summer Vision Project: Seymour Papert e Marvin Minsky criaram um

Sistema para identificar objetos em imagens.
⁻ 1979 - Kunihiko Fukushima propõe o Neocognitron: um sistema de visão
computacional baseado no córtex visual humano.
⁻ 1980s - Nos anos 80 o francês Yann LeCun introduz a Rede Neural
Convolucional (CNN), inspirada no Neocognitron (mas requer muito
processamento)
⁻ 1994 - Yann LeCun cria a LeNet5: primeria CNN amplamente utilizada
⁻ 2012 - AlexNet criada por pesquisadores de Toronto, vence a competição
ImageNet (Redes Neurais conseguem ser processadas), baseada na LeNet e
utilizando GPUs
⁻ 2014 - DeepFace do Facebook atinge 97% de precisão
 Redes Neurais para Visão
Computacional
LeNet: Uma das primeiras redes neurais convolucionais
reconhecimento de dígitos manuscritos em imagens.
Consiste em duas partes: (i) um codificador
convolucional que consiste em duas camadas
convolucionais; e (ii) um bloco denso que consiste em
três camadas totalmente conectadas;

AlexNet consiste em oito camadas: cinco camadas

convolucionais, duas camadas ocultas totalmente
conectadas e uma camada de saída totalmente
conectada. As Convoluções agrupadas são usadas para
ajustar o modelo em duas GPUs.
Redes Neurais para Visão Computacional

VGG (Grupo de Geometria Visual )

foi desenvolvido para aumentar a
profundidade de tais CNNs a fim de
aumentar o desempenho do
modelo.
É uma arquitetura padrão de Rede
Neural Convolucional (CNN)
profunda com múltiplas camadas. O
“profundo” refere-se ao número de
camadas com VGG-16 ou VGG-19
consistindo em 16 e 19 camadas
convolucionais.
MNIST

• “Hello World” da Visão Computacional

• É um Dataset de dígitos escritos à mão
• Este Dataset é utilizado para treinar modelos
que reconhecem dígitos
• Contêm 70 mil imagens de 28x28 pixels com
imagens de dígitos de 0 a 9
• Modified National Institute of Standards and
Tecnology
 MNIST
from keras.datasets import mnist
from matplotlib import pyplot
from tensorflow import keras
import numpy as np

(train_x, train_y), (test_x, test_y) = mnist.load_data()

print('train_x: ' + str(train_x.shape))
print('train_y: ' + str(train_y.shape))
print('test_x: ' + str(test_x.shape))
print('test_y: ' + str(test_y.shape))

for i in range(9):
pyplot.subplot(3, 3, 1+i)
pyplot.imshow(train_x[i], cmap=pyplot.get_cmap('gray'))
pyplot.show()

Continua no próximo
SLIDE
 MNIST
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy’])
RELU é a função que tem
comportamento mais semelhante ao
neurônio biológico e gasta pouco;
Softmax é a função que tem soma de
probabilidades igual a 1, por isso é usada
normalmente na última camada

model.fit(train_x, train_y, epochs=10)

test_loss, test_acc = model.evaluate(test_x, test_y, verbose=2)

print('Acurácia:', test_acc)

predictions = model.predict(test_x)
print(predictions[0])
print(np.argmax(predictions[0]))
print(test_y[0])
 Fashion MNIST
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
print(tf.__version__)
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
print(train_images.shape)
print(len(train_labels))
print(test_images.shape)
print(len(test_labels))

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False) Continua no próximo
plt.show() SLIDE
 Fashion MNIST
train_images = train_images / 255.0
test_images = test_images / 255.0

plt.figure(figsize=(10,10))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
plt.show()

Continua no próximo
SLIDE
 Fashion MNIST

model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10)

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print('Acurácia:', test_acc)

predictions = model.predict(test_images)
print(predictions[0])
print(np.argmax(predictions[0]))
print(test_labels[0])

for i in range(30):
print('Previsto:', np.argmax(predictions[i]), "Esperado:", test_labels[i])
Convolutional Neural Network (CNN)

• Cada camada extrai uma característica específica da imagem

• Uma camada pode extrair por exemplo margens horizontais e verticais

• Conforme vai para o fundo, as próximas camadas detectam

características mais complexas como cantos e formas

• As camadas finais detectam coisas específicas como faces, portas e

carros
Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)
 Convolutional Neural
Network (CNN)

• CIFAR10 é um Dataset com 60 mil imagens

coloridas
• 50 mil para treinamento e 10 mil para teste
• Possui 10 classes (mutualmente exclusivas)
• Cada imagem possui 32x32 pixels
• As imagens de testes são selecionadas
aleatoriamente
 Convolutional Neural Network (CNN)
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']

plt.figure(figsize=(10,10))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i][0]])
plt.show()

Continua no próximo
SLIDE
 Convolutional Neural Network (CNN)
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
history = model.fit(train_images, train_labels, epochs=10,
validation_data=(test_images, test_labels))
model.summary()

Continua no próximo
SLIDE
 Convolutional Neural Network (CNN)
plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 1])
plt.legend(loc='lower right’)

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print(test_acc)
Convolutional Neural Network (CNN)

Decidir se uma figura possui X ou O

Convolutional Neural Network (CNN)

Decidir se uma figura possui X ou O

Convolutional Neural Network (CNN)

Decidir se uma figura possui X ou O

 Convolutional Neural Network (CNN)

Multiplicar cada pixel da imagem pelo pixel correspondente do filtro (convolução ou kernel)
Adicionar ao somatório
Dividir pelo total de elementos
 Convolutional Neural Network (CNN)

Multiplicar cada pixel da imagem pelo pixel correspondente do filtro (convolução ou kernel)
Adicionar ao somatório
Dividir pelo total de elementos
Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)

Na camada de convolução uma imagem gera várias imagens

Convolutional Neural Network (CNN)

• O objetivo da camada de pooling é reduzir a quantidade de parâmetros

selecionando o valor máximo, media ou soma de pixels

• A Max pooling é a mais utilizada

• A camada pooling torna a convolução invariante a translação, rotação e

shifting (janelamento)

• Também chamada de downsample

Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)
Convolutional Neural Network (CNN)

Um conjunto de entradas gera saídas menores

YOLO
YOLO
 YOLO

Scaled YOLO v4 superou em acurácia as seguintes

redes neurais:
• Google EfficientDet D7x / DetectoRS or SpineNet-190
• Amazon Cascade-RCNN ResNest200
• Microsoft RepPoints v2
• Facebook RetinaNet SpineNet-190
 YOLO

• YOLO (You Only Look Once) é um algoritmo de reconhecimento de

objetos
• Foi descrito em 2015 no artigo de Joseph Redmon et al.
• Possui várias implementações open-source: Darknet (C e CUDA), Keras
(Python), PyTorch (Python)
• Utiliza uma rede neural para prever as probabilidades das bounding
boxes em uma única avaliação
• Processa imagens em tempo real (45 - 155 FPS)
 YOLO

• Não utiliza rede neural do tipo RCNN (Region-based convolutional

neural network) pois esta solução é mais lenta (1000 vezes mais lenta,
pois seleciona as ROI e classifica cada com CNN)
• YOLO utiliza regressão portanto é um algoritmo de uma avaliação
• É possível utilizar uma rede neural pré-treinada (Darknet treinada com
o dataset COCO) ou treinar uma do zero
• Permite processamento paralelo
• Projetado para ser treinado com uma única GPUs (mais barato)
 YOLO

Compatível com TensorRT (Nvidia)

YOLO
 YOLO

O algoritmo YOLO tenta prever 4 dados:

• bxby: centro do bounding box

• bw: largura

• bh: altura

• cis: classe do objeto (carro, semáforo, etc)

 YOLO

pc: probabilidade que existe um objeto na bounding box

 YOLO

Non-max suppresion: as bounding box com baixo pc são removidas

YOLO - Arquitetura
YOLO - Arquitetura
 YOLO

Técnicas para Redes Neurais foram combinadas para atingir resultados do

estado-da-arte:
• Weighted-Residual-Connections (WRC)
• Cross-Stage-Partial-connections (CSP)
• Cross mini-Batch
• Normalization (CmBN)
• Self-adversarial-training (SAT)
• Mish-activation
 COCO Dataset

• COCO (Common Objects in Context) patrocinada pela Microsoft e Face

• 330 mil imagens (mais de 200 mil com label)

• 80 categorias (classes) de objetos

• 91 categorias (classes) de stuffs (objetos amorfos como grama e céu)

• 250 mil pessoas com keypoints

COCO Dataset - Categorias
COCO Dataset
 Instalação
Projeto YOLOV4 com Python no Github:
https://github.com/search?q=yolov4+python
 Instalação
Projeto de implementação do YOLO no Keras:
https://github.com/taipingeric/yolo-v4-tf.keras.git
 Instalação
Projeto de implementação do YOLO no Keras:
https://github.com/taipingeric/yolo-v4-tf.keras.git
 Instalação
CUDA (https://developer.nvidia.com/cuda-toolkit-archive)

Download official YOLO v4 pre-trained weights:

https://drive.google.com/file/d/1cewMfusmPjYWbrnuJRuKhPMwRe_b9PaT/view

Converter modelo da Darknet para YOLO:

python yad2k.py cfg\yolo.cfg yolov3.weights data\yolo.h5

pip install numpy

pip install keras
pip install tensorflow-gpu
pip install opencv-python
pip install tqdm
pip install matplotlib
pip install pandas
pip install sklearn
Instalação
 Exemplo

teste.py

from models import Yolov4

model = Yolov4(weight_path='./yolov4.weights',
class_name_path='./class_names/coco_classes.txt')
model.predict('./img/assaltante.jpg', random_color=True)
Exemplo
 Exemplo

Como treinar a rede com um dataset customizado:

https://medium.com/analytics-vidhya/train-a-custom-yolov4-object-
detector-using-google-colab-61a659d4868

https://blog.roboflow.com/training-yolov4-on-a-custom-dataset/

https://medium.com/geekculture/train-a-custom-yolov4-object-
detector-on-windows-fe5332b0ca95

https://blog.paperspace.com/how-to-train-scaled-yolov4-object-
detection/
 Referências

Treine sua primeira rede neural: classificação básica

https://www.tensorflow.org/tutorials/keras/classification?hl=pt-br

Activation Functions
https://medium.com/@himanshuxd/activation-functions-sigmoid-relu-leaky-relu-
and-softmax-basics-for-neural-networks-and-deep-8d9c70eed91e

What Is Computer Vision?

https://www.pcmag.com/news/what-is-computer-vision

Neural Network Architectures

https://towardsdatascience.com/neural-network-architectures-156e5bad51ba

Redes Neurais Convolucionais - Prof. Anderson Soares

www.inf.ufg.br/~anderson
 Referências

YOLO Algorithm and YOLO Object Detection: An Introduction

https://appsilon.com/object-detection-yolo-algorithm/

Github: taipingeric/yolo-v4-tf.keras
https://github.com/taipingeric/yolo-v4-tf.keras

Scaled YOLO v4 is the best neural network for object detection on MS

COCO dataset
https://alexeyab84.medium.com/scaled-yolo-v4-is-the-best-neural-
network-for-object-detection-on-ms-coco-dataset-39dfa22fa982

YOLOv4: Optimal Speed and Accuracy of Object Detection

https://arxiv.org/pdf/2004.10934.pdf