El aprendizaje automático es una técnica cada vez más importante en el campo de la visión artificial. A través del aprendizaje automático, podemos entrenar sistemas para detectar y clasificar objetos específicos en una imagen o video utilizando datos previamente etiquetados. OpenCV proporciona una gran cantidad de funciones y herramientas para el uso de técnicas de aprendizaje automático, lo que lo convierte en una opción ideal para el desarrollo de sistemas de visión artificial avanzados.
Uno de los algoritmos de aprendizaje automático más comunes en el campo de la visión artificial es el algoritmo de clasificación SVM (Support Vector Machine). SVM es un algoritmo de aprendizaje automático supervisado que se utiliza para clasificar datos en diferentes categorías. OpenCV proporciona una implementación de SVM que se puede utilizar para clasificar objetos en una imagen o video.
Por ejemplo, si queremos entrenar un sistema SVM para clasificar imágenes de gatos y perros, podemos utilizar el siguiente código:
Subscríbete a nuestro blog
import cv2
import numpy as np
# Cargar los datos de entrenamiento (imágenes de gatos y perros)
data = np.load("training_data.npy")
# Dividir los datos en atributos (imágenes) y etiquetas (gato/perro)
X, y = data[:, :-1], data[:, -1]
# Crear el modelo SVM
svm = cv2.ml.SVM_create()
svm.setType(cv2.ml.SVM_C_SVC)
svm.setKernel(cv2.ml.SVM_LINEAR)
svm.setC(1.0)
# Entrenar el modelo SVM con los datos de entrenamiento
svm.train(X, cv2.ml.ROW_SAMPLE, y)
# Utilizar el modelo SVM para clasificar nuevas imágenes
img = cv2.imread("test_image.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Extraer características de la imagen
sift = cv2.xfeatures2d.SIFT_create()
kp, des = sift.detectAndCompute(gray, None)
#Utilizar el modelo SVM para clasificar la imagen
result = svm.predict(des)
#Mostrar el resultado de la clasificación
if result[1][0][0] == 0:
print("Gato")
else:
print("Perro")
Este ejemplo muestra cómo se puede utilizar el algoritmo SVM de OpenCV para entrenar un sistema de clasificación con datos previamente etiquetados de imágenes de gatos y perros, y luego utilizar ese sistema para clasificar nuevas imágenes. En este caso, se utiliza el descriptor SIFT para extraer características de las imágenes antes de ser clasificadas.
Otro algoritmo de aprendizaje automático popular en el campo de la visión artificial es el algoritmo de detección de objetos basado en deep learning, como YOLO (You Only Look Once) y SSD (Single Shot MultiBox Detector). Estos algoritmos utilizan redes neuronales profundas para detectar objetos en una imagen o video. OpenCV proporciona una interfaz para utilizar estos algoritmos mediante la carga de un modelo preentrenado.
Por ejemplo, si queremos utilizar el algoritmo YOLO para detectar objetos en una imagen, podemos utilizar el siguiente código:
import cv2
import numpy as np
# Cargar el modelo pre-entrenado de YOLO
net = cv2.dnn.readNetFromDarknet("yolov3.cfg", "yolov3.weights")
# Definir las capas de salida del modelo
ln = net.getLayerNames()
ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
# Cargar la imagen
img = cv2.imread("image.jpg")
(H, W) = img.shape[:2]
# Crear un blob a partir de la imagen
blob = cv2.dnn.blobFromImage(img, 1 / 255.0, (416, 16), swapRB=True, crop=False)
# Enviar el blob a la red neuronal
net.setInput(blob)
layerOutputs = net.forward(ln)
# Inicializar las listas para almacenar las detecciones y las probabilidades
boxes = []
confidences = []
# Recorrer las salidas de la capa
for output in layerOutputs:
# Recorrer las detecciones
for detection in output:
# Extraer las probabilidades y las coordenadas de las cajas delimitadoras
scores = detection[5:]
classID = np.argmax(scores)
confidence = scores[classID]
# Filtrar las detecciones con baja probabilidad
if confidence > 0.5:
# Calcular las coordenadas de las cajas delimitadoras
box = detection[0:4] * np.array([W, H, W, H])
(centerX, centerY, width, height) = box.astype("int")
# Calcular las coordenadas de inicio y fin de las cajas delimitadoras
x = int(centerX - (width / 2))
y = int(centerY - (height / 2))
# Actualizar las listas
boxes.append([x, y, int(width), int(height)])
confidences.append(float(confidence))
# Aplicar el algoritmo de suavizado de cajas delimitadoras
indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.3)
# Dibujar las cajas delimitadoras y las etiquetas en la imagen
for i in indices:
i = i[0]
box = boxes[i]
x, y, w, h = box[0], box[1], box[2], box[3]
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.putText(img, "Object", (x, y - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
#Mostrar la imagen con las detecciones
cv2.imshow("Detecciones", img)
cv2.waitKey()
cv2.destroyAllWindows()
Este ejemplo muestra cómo se puede utilizar un modelo preentrenado de YOLO en OpenCV para detectar objetos en una imagen. En este caso, se utiliza una imagen y se crea un blob a partir de ella antes de enviarlo a la red neuronal. Luego se recorren las salidas de la red neuronal para extraer las detecciones y las probabilidades, y se aplica un algoritmo de suavizado de cajas delimitadoras para reducir la cantidad de detecciones sobrepuestas. Finalmente, se dibujan las cajas delimitadoras y las etiquetas en la imagen para mostrar las detecciones.
En resumen, el uso de técnicas de aprendizaje automático con OpenCV es una forma eficaz de desarrollar sistemas de visión artificial avanzados. OpenCV proporciona una gran cantidad de funciones y herramientas para el uso de algoritmos de aprendizaje automático, incluyendo SVM, redes neuronales y algoritmos de detección de objetos basados en deep learning. Es importante tener un conocimiento previo de la teoría detrás de estas técnicas, saber cómo configurar y utilizar los algoritmos adecuados para el problema específico que se desea resolver y tener habilidades en programación con Python.