El taller de datos

¡Hola a todos! Hoy quiero compartir un ejercicio que he estado haciendo para entender cómo funciona el Histogram of Oriented Gradients (HOG), un popular descriptor de características utilizado para la detección de objetos. En mi caso, lo usé para detectar a una persona en una imagen.

¿Qué es HOG?

Antes de entrar en el código, una breve explicación. HOG es una técnica que describe la forma o la apariencia de un objeto en una imagen analizando la distribución de la intensidad de los gradientes (es decir, cómo cambian los colores de los píxeles). Básicamente, HOG toma una imagen y la convierte en un vector de características que representa la estructura de los bordes.

Manos a la obra: Nuestro ejercicio

Para este proyecto, he utilizado Python con las librerías OpenCV y scikit-image. El objetivo es simple: leer una imagen y detectar a la persona que aparece en ella.

1. Preparación y carga de la imagen

Lo primero es importar las librerías necesarias y cargar la imagen que vamos a analizar.

Python

import numpy as np
import matplotlib.pyplot as plt

from skimage.io import imread
from skimage.transform import resize
from skimage.feature import hog
from skimage import exposure
from skimage import data
from cv2 import filter2D

# Carga de la imagen (sustituye 'person.jpg' por el nombre de tu archivo)


# Leemos la imagen y la pasamos a escala de grises haciendo la media por canales
im = data.astronaut().mean(axis = 2)
plt.figure()
plt.title("Imagen original")
plt.imshow(image)
plt.show()

Imágen:

2. Cálculo de HOG

Ahora viene el paso crucial. Usaremos la función hog de scikit-image. Esta función no solo calcula el descriptor HOG, sino que también nos devuelve la imagen con los gradientes visualizados, lo cual es perfecto para entender lo que está haciendo el algoritmo.

Python

# Redimensionamos la imagen para un tamaño estándar
resized_img = resize(image, (128*4, 64*4), anti_aliasing=True)

# Calculamos el descriptor HOG
fd, hog_image = hog(resized_img, orientations=9, pixels_per_cell=(8, 8),
                    cells_per_block=(2, 2), visualize=True)

En este código:

• orientations: Son la cantidad de «direcciones» de gradiente que se consideran.
• pixels_per_cell: Define el tamaño de la celda donde se calculan los gradientes.
• cells_per_block: Agrupa las celdas para normalizar los resultados, haciendo el algoritmo más robusto.

3. Visualización de los resultados

Para ver cómo HOG «ve» nuestra imagen, vamos a mostrar la imagen de los gradientes.

Python

# Aumentamos el contraste de la imagen HOG para que sea más visible
hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)

ax1.axis('off')
ax1.imshow(resized_img, cmap=plt.cm.gray)
ax1.set_title('Imagen original')

ax2.axis('off')
ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
ax2.set_title('Histogram of Oriented Gradients')
plt.show()

Imagen vs HOG:

Lo que hemos hecho hasta ahora es generar el descriptor HOG. Para una detección real de objetos, este descriptor se usaría como entrada para un clasificador (como un SVM), que ha sido entrenado con miles de imágenes de personas y no-personas. El clasificador usaría las características de HOG para determinar si la imagen (o una parte de ella) contiene el objeto que buscamos.

Al transformar una imagen en un conjunto de gradientes orientados, el algoritmo es capaz de «ver» las formas y estructuras clave, como los contornos de una persona, de una manera que es muy útil para la detección de objetos.

Si te ha parecido interesante, te animo a explorar algunos de los siguientes pasos como Entrenar un clasificador: El siguiente paso lógico sería usar este descriptor HOG para entrenar un clasificador (por ejemplo, un SVM, o una máquina de vectores de soporte).

El algoritmo HOG (Histogram of Oriented Gradients) y otras técnicas similares fueron muy importantes en su momento. HOG funciona extrayendo características de forma manual. Es decir, los humanos diseñamos el algoritmo para que detecte bordes y formas de una manera específica, como ya vimos en el ejemplo.

Sin embargo, las redes neuronales convolucionales (CNNs) llevaron este concepto un paso más allá al automatizar ese proceso. En lugar de que un humano defina las características a buscar (como los gradientes de HOG), una CNN aprende automáticamente cuáles son las características más importantes de una imagen para resolver una tarea específica (como detectar a una persona, un coche, o cualquier otro objeto)