En este artículo, aprenderá cómo completar tres tareas de visión por computadora en Python fáciles de usar para principiantes (detección de bordes, detección de objetos simples y clasificación de imágenes) utilizando bibliotecas ampliamente disponibles.
Los temas que cubriremos incluyen:
Instalación y configuración de las bibliotecas de Python necesarias. Detección de aristas y caras con herramientas clásicas de OpenCV. Entrenamiento de una red neuronal convolucional compacta para clasificación de imágenes.
Exploremos estas técnicas.
La guía para principiantes sobre visión por computadora con Python
Imagen del editor
Introducción
La visión por computadora es un área de la inteligencia artificial que brinda a los sistemas informáticos la capacidad de analizar, interpretar y comprender datos visuales, es decir, imágenes y videos. Abarca todo, desde tareas clásicas como filtrado de imágenes, detección de bordes y extracción de características, hasta tareas más avanzadas como clasificación de imágenes y videos y detección de objetos complejos, que requieren la creación de modelos de aprendizaje automático y aprendizaje profundo.
Afortunadamente, las bibliotecas de Python como OpenCV y TensorFlow hacen posible, incluso para los principiantes, crear y experimentar con sus propias soluciones de visión por computadora usando solo unas pocas líneas de código.
Este artículo está diseñado para guiar a los principiantes interesados en la visión por computadora a través de la implementación de tres tareas fundamentales de la visión por computadora:
Procesamiento de imágenes para detección de bordes Detección simple de objetos, como caras Clasificación de imágenes
Para cada tarea, proporcionamos un ejemplo de trabajo mínimo en Python que utiliza datos integrados o disponibles gratuitamente, acompañado de las explicaciones necesarias. Puede ejecutar este código de manera confiable en un entorno compatible con computadoras portátiles, como Google Colab, o localmente en su propio IDE.
Configuración y preparación
Un requisito previo importante para utilizar el código proporcionado en este artículo es instalar varias bibliotecas de Python. Si ejecuta el código en un cuaderno, pegue este comando en una celda inicial (use el prefijo “!” en los cuadernos):
pip install opencv-python tensorflow scikit-image matplotlib numpy
pip install opencv – python tensorflow scikit – image matplotlib numpy
Procesamiento de imágenes con OpenCV
OpenCV es una biblioteca de Python que ofrece una variedad de herramientas para crear de manera eficiente aplicaciones de visión por computadora, desde transformaciones básicas de imágenes hasta tareas simples de detección de objetos. Se caracteriza por su rapidez y amplia gama de funcionalidades.
Una de las principales áreas de tareas soportadas por OpenCV es el procesamiento de imágenes, que se centra en aplicar transformaciones a las imágenes, generalmente con dos objetivos: mejorar su calidad o extraer información útil. Los ejemplos incluyen convertir imágenes en color a escala de grises, detectar bordes, suavizar para reducir el ruido y establecer umbrales para separar regiones específicas (por ejemplo, el primer plano del fondo).
El primer ejemplo de esta guía utiliza una imagen de muestra incorporada proporcionada por la biblioteca scikit-image para detectar bordes en la versión en escala de grises de una imagen originalmente a todo color.
from skimage import data
import cv2
import matplotlib.pyplot as plt
# Load a sample RGB image (astronaut) from scikit-image
image = data.astronaut()
# Convert RGB (scikit-image) to BGR (OpenCV convention), then to grayscale
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Canny edge detection
edges = cv2.Canny(gray, 100, 200)
# Display
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.imshow(gray, cmap=”gray”)
plt.title(“Grayscale Image”)
plt.axis(“off”)
plt.subplot(1, 2, 2)
plt.imshow(edges, cmap=”gray”)
plt.title(“Edge Detection”)
plt.axis(“off”)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from skimage import data
import cv2
import matplotlib . pyplot as plt
# Load a sample RGB image (astronaut) from scikit-image
image = data . astronaut ( )
# Convert RGB (scikit-image) to BGR (OpenCV convention), then to grayscale
image = cv2 . cvtColor ( image , cv2 . COLOR_RGB2BGR )
gray = cv2 . cvtColor ( image , cv2 . COLOR_BGR2GRAY )
# Canny edge detection
edges = cv2 . Canny ( gray , 100 , 200 )
# Display
plt . figure ( figsize = ( 10 , 4 ) )
plt . subplot ( 1 , 2 , 1 )
plt . imshow ( gray , cmap = “gray” )
plt . title ( “Grayscale Image” )
plt . axis ( “off” )
plt . subplot ( 1 , 2 , 2 )
pl . estoy mostrando ( bordes , cmap = "gris" )
pl . título ( "Detección de bordes" )
pl . eje ( "apagado" )
pl . espectáculo ( )
El proceso aplicado en el código anterior es simple, pero ilustra un escenario de procesamiento de imágenes muy común:
Cargue y preprocese una imagen para su análisis: convierta la imagen RGB a la convención BGR de OpenCV y luego a escala de grises para su posterior procesamiento. Funciones como COLOR_RGB2BGR y COLOR_BGR2GRAY hacen que esto sea sencillo. Utilice el algoritmo de detección de bordes Canny integrado para identificar los bordes de la imagen. Trazar los resultados: la imagen en escala de grises utilizada para la detección de bordes y el mapa de bordes resultante.
Los resultados se muestran a continuación:
Detección de bordes con OpenCV
Detección de objetos con OpenCV
Es hora de ir más allá del procesamiento clásico a nivel de píxeles e identificar objetos de nivel superior dentro de una imagen. OpenCV hace esto posible con modelos previamente entrenados como las cascadas Haar, que se pueden aplicar a muchas imágenes del mundo real y funcionan bien para casos de uso de detección simples, por ejemplo, detectar rostros humanos.
El siguiente código utiliza la misma imagen de astronauta que en la sección anterior, la convierte a escala de grises y aplica una cascada de Haar entrenada para identificar caras frontales. Los metadatos de la cascada están contenidos en haarcascade_frontalface_default.xml.
from skimage import data
import cv2
import matplotlib.pyplot as plt
# Load the sample image and convert to BGR (OpenCV convention)
image = data.astronaut()
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
# Haar cascade is an OpenCV classifier trained for detecting faces
face_cascade = cv2.CascadeClassifier(
cv2.data.haarcascades + “haarcascade_frontalface_default.xml”
)
# The model requires grayscale images
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Detect faces
faces = face_cascade.detectMultiScale(
gray, scaleFactor=1.1, minNeighbors=5
)
# Draw bounding boxes
output = image.copy()
for (x, y, w, h) in faces:
cv2.rectangle(output, (x, y), (x + w, y + h), (0, 255, 0), 2)
# Display
plt.imshow(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
plt.title(“Face Detection”)
plt.axis(“off”)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from skimage import data
import cv2
import matplotlib . pyplot as plt
# Load the sample image and convert to BGR (OpenCV convention)
image = data . astronaut ( )
image = cv2 . cvtColor ( image , cv2 . COLOR_RGB2BGR )
# Haar cascade is an OpenCV classifier trained for detecting faces
face_cascade = cv2 . CascadeClassifier (
cv2 . data . haarcascades + “haarcascade_frontalface_default.xml”
)
# The model requires grayscale images
gray = cv2 . cvtColor ( image , cv2 . COLOR_BGR2GRAY )
# Detect faces
faces = face_cascade . detectMultiScale (
gray , scaleFactor = 1.1 , minNeighbors = 5
)
# Draw bounding boxes
output = image . copy ( )
for ( x , y , w , h ) in faces :
cv2 . rectangle ( output , ( x , y ) , ( x + w , y + h ) , ( 0 , 255 , 0 ) , 2 )
# Display
pl . imshow ( cv2 . cvtColor ( salida , cv2 . COLOR_BGR2RGB ) )
pl . título ( "Detección de rostros" )
pl . eje ( "apagado" )
pl . espectáculo ( )
Observe que el modelo puede devolver uno o varios objetos detectados (caras) en una lista almacenada en caras. Para cada objeto detectado, extraemos las coordenadas de las esquinas que definen los cuadros delimitadores que encierran la cara.
Resultado:
Detección de rostros con OpenCV
Clasificación de imágenes con TensorFlow
Las tareas de clasificación de imágenes juegan en otra liga. Estos problemas dependen en gran medida del conjunto de datos específico (o al menos de datos con propiedades estadísticas similares). La principal implicación práctica es que se requiere entrenar un modelo de aprendizaje automático para la clasificación. Para imágenes simples de baja resolución, los métodos de conjunto como bosques aleatorios o redes neuronales poco profundas pueden ser suficientes, pero para imágenes complejas de alta resolución, la mejor opción suele ser arquitecturas de redes neuronales más profundas, como las redes neuronales convolucionales (CNN), que aprenden características y patrones visuales entre clases.
Este código de ejemplo utiliza el popular conjunto de datos Fashion-MNIST de imágenes de ropa de baja resolución, con ejemplos distribuidos en 10 clases (camisa, pantalones, zapatillas de deporte, etc.). Después de una simple preparación de datos, el conjunto de datos se divide en conjuntos de entrenamiento y prueba. En el aprendizaje automático, el conjunto de entrenamiento se pasa junto con etiquetas (clases conocidas para imágenes) para que el modelo pueda aprender las relaciones entrada-salida. Después de entrenar el modelo (definido aquí como una CNN simple), los ejemplos restantes del conjunto de pruebas se pueden pasar al modelo para realizar predicciones de clase, es decir, para inferir qué tipo de producto de moda se muestra en una imagen determinada.
import tensorflow as tf
from tensorflow.keras import layers, models
# Load Fashion-MNIST dataset (publicly available)
(train_images, train_labels), (test_images, test_labels) =
tf.keras.datasets.fashion_mnist.load_data()
# Normalize pixel values for more robust training
train_images = train_images.astype(“float32”) / 255.0
test_images = test_images.astype(“float32″) / 255.0
# Simple CNN architecture with one convolution layer: enough for low-res images
model = models.Sequential([
layers.Reshape((28, 28, 1), input_shape=(28, 28)),
layers.Conv2D(32, 3, activation=”relu”),
layers.MaxPooling2D(),
layers.Flatten(),
layers.Dense(64, activation=”relu”),
layers.Dense(10, activation=”softmax”)
])
# Compile and train the model
model.compile(
optimizer=”adam”,
loss=”sparse_categorical_crossentropy”,
metrics=[“accuracy”]
)
history = model.fit(
train_images,
train_labels,
epochs=5,
validation_split=0.1,
verbose=2
)
# (Optional) Evaluate on the test set
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=0)
print(f”Test accuracy: {test_acc:.3f}”)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import tensorflow as tf
from tensorflow . keras import layers , models
# Load Fashion-MNIST dataset (publicly available)
( train_images , train_labels ) , ( test_images , test_labels ) =
tf . keras . datasets . fashion_mnist . load_data ( )
# Normalize pixel values for more robust training
train_images = train_images . astype ( “float32” ) / 255.0
test_images = test_images . astype ( “float32” ) / 255.0
# Simple CNN architecture with one convolution layer: enough for low-res images
model = models . Sequential ( [
layers . Reshape ( ( 28 , 28 , 1 ) , input_shape = ( 28 , 28 ) ) ,
layers . Conv2D ( 32 , 3 , activation = “relu” ) ,
layers . MaxPooling2D ( ) ,
layers . Flatten ( ) ,
layers . Dense ( 64 , activation = “relu” ) ,
capas . Denso ( 10 , activación = "softmax" )
] )
# Compile y entrene el modelo.
modelo . compilar (
optimizador = "adam" ,
pérdida = "sparse_categorical_crossentropy" ,
métricas = [ "precisión" ]
)
historia = modelo . adaptar (
imágenes_tren ,
etiquetas_tren ,
épocas = 5 ,
división_validación = 0.1 ,
detallado = 2
)
# (Opcional) Evaluar en el conjunto de prueba
pérdida_prueba , prueba_acc = modelo . evaluar ( prueba_imagenes , etiquetas_prueba , detallado = 0 )
print ( f "Precisión de la prueba: {test_acc:.3f}" )
Entrenando una clasificación de imágenes con TensorFlow
Y ahora tienes un modelo entrenado.
Concluyendo
Este artículo guió a los principiantes a través de tres tareas comunes de visión por computadora y mostró cómo abordarlas utilizando bibliotecas de Python como OpenCV y TensorFlow, desde el procesamiento de imágenes clásico y detectores previamente entrenados hasta el entrenamiento de un pequeño modelo predictivo desde cero.