Paso 1: Arquivos necesarios para este reto

Importante: > Para que este reto funcione en Google Colab é necesario que subas tres arquivos: > 1. A imaxe na que queres detectar obxectos. > 2. O arquivo de definición do modelo: MobileNetSSD_deploy.prototxt.txt > 3. O arquivo cos pesos do modelo: MobileNetSSD_deploy.caffemodel > > Podes descargar estes dous últimos desde Internet (buscaralos cos seus nomes). Asegúrate de telos para subilos a Colab con este código:

import cv2
import numpy as np
from google.colab import files
from google.colab.patches import cv2_imshow

# ------------------------------------------------------------------
# 1. Subir os arquivos necesarios:
# Pediráselle ó usuario que suba a imaxe, o arquivo .prototxt e o .caffemodel.
# ------------------------------------------------------------------

print("Sube a imaxe:")
uploaded = files.upload()
for ficheiro in uploaded.keys():
imaxe = cv2.imread(ficheiro)

print("Sube o arquivo MobileNetSSD_deploy.prototxt.txt:")
uploaded = files.upload()
for ficheiro in uploaded.keys():
ruta_prototxt = ficheiro

print("Sube o arquivo MobileNetSSD_deploy.caffemodel:")
uploaded = files.upload()
for ficheiro in uploaded.keys():
ruta_modelo = ficheiro

 Paso 2: Cargar o modelo con OpenCV

Este código fai que teñamos a disposición o modelo para que traballe para nós e tamén lle dicimos como queremos que lle chame a cada obxecto( como non el os ten en inglés) que pode detectar o modelo:

# ------------------------------------------------------------------
# 2. Cargar o modelo preentrenado usando OpenCV
# ------------------------------------------------------------------

rede = cv2.dnn.readNetFromCaffe(ruta_prototxt, ruta_modelo)

# ------------------------------------------------------------------
# 3. Definir as clases(tipos de obxectos) que o modelo pode detectar.
# A primeira clase é "background", que non nos interesa, despois veñen os obxectos.
# ------------------------------------------------------------------

CLASES = ["background", "avión", "bicicleta", "paxaro", "barco",
"botella", "autobús", "coche", "gato", "cadeira", "vaca",
"mesa de comedor", "can", "cabalo", "moto", "persoa",
"planta en maceta", "ovella", "sofá", "tren", "monitor"]

Paso 3: Preparar a imaxe para que poda "probar" o modelo 

Preparar a imaxe para o modelo: Transfórmase a imaxe nun "blob" (unha maneira de transformar a imaxe para que a rede neuronal enténdaa).

Obter as deteccións: Pásase o "blob" polo modelo e este devolve a información sobre que obxectos atopou e onde están na imaxe.

# ------------------------------------------------------------------
# 4. Preparar a imaxe para o modelo
# Créase un "blob", que é como transformar a imaxe a un formato que entende o modelo.
# A imaxe redimensionase a 300x300 píxeles e normalízase.
# ------------------------------------------------------------------

(h, w) = imaxe.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(imaxe, (300, 300)),0.007843, (300, 300), 127.5)

# ------------------------------------------------------------------

# 5. Pasar o blob polo modelo para obter as deteccións
# ------------------------------------------------------------------

rede.setInput(blob)
deteccións = rede.forward()

Paso 4: Obter o nivel de certeza na detección e debuxar os rectángulos na imaxe

Percórrese a lista de deteccións e, para cada obxecto que o modelo atopou con suficiente seguridade (máis do 20%), debúxase un rectángulo azul ao seu  redor e escríbese o nome do obxecto e a porcentaxe de certeza.

# ------------------------------------------------------------------
# 6. Procesar as deteccións e debuxar os rectángulos e etiquetas
# ------------------------------------------------------------------

for i in np.arange(0, deteccións.shape[2]):

# Obter a confianza (o nivel de certeza do modelo na detección)

confianza = deteccións[0, 0, i, 2]

# Só consideramos deteccións cunha confianza maior do 20%

if confianza > 0.2:

# Obter o índice da clase detectada e o nome (exemplo: "persoa")

idx = int(deteccións[0, 0, i, 1])
etiqueta = CLASES[idx]

# Calcular as coordenadas do rectángulo (adaptándoas á imaxe orixinal)

caixa = deteccións[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = caixa.astype("int")

# Debuxar o rectángulo na imaxe (cor azul)

cv2.rectangle(imaxe, (startX, startY), (endX, endY), (255, 0,0), 2)

# Escribir a etiqueta e a confianza sobre o rectángulo

y = startY - 15 if startY - 15 > 15 else startY + 15
texto = "{}: {:.2f}%".format(etiqueta, confianza * 100)
cv2.putText(imaxe, texto, (startX, y),cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,0 , 0), 2)

# ------------------------------------------------------------------
# 7. Amosar a imaxe cos obxectos recoñecidos
# ------------------------------------------------------------------

cv2_imshow(imaxe)

Paso 5: Agora tócache a tÍ !!!!

 Propoñoche:

• Proba o programa completo para comprender o seu funcionamento con distintas imaxes
• Proba a cambiar as cores do rectángulo e do texto
• Que ocorre se cambiamos o límite de confianza?Proba coa mesma imaxe varios límites máis altos e baixos e razona sobre o resultado
• Neste momento, cada vez que queres probar o programa, tes que subir os 3 arquivos e esperar un pouco...que che parece se usamos Python básico para:
  • Crear unha función def procesar_imaxe(rede, CLASES) para subir a imaxe, preparala e pasala polo modelo, procesar as detección, debuxar os rectángulos e mostrar os resultados
  • Procesar imaxes con while True: de xeito iterativo, para poder decidir se queremos ou non procesar máis imaxes.

Ánimo! Só é mover uns bloqueciños de código!