C++ OpenCV Aprendizaje automático y aprendizaje profundo
OpenCV no solo admite tareas tradicionales de visión por computadora, sino que también ofrece potentes funciones de aprendizaje automático y aprendizaje profundo. A través de estas funciones, se pueden realizar tareas complejas como clasificación de imágenes, detección de objetos y segmentación semántica.
Aprendizaje automático: OpenCV proporciona varios algoritmos tradicionales de aprendizaje automático, como KNN, SVM, árboles de decisión, etc.
Aprendizaje profundo: El módulo DNN de OpenCV admite la carga y ejecución de modelos de aprendizaje profundo preentrenados (como TensorFlow, PyTorch, Caffe, etc.).
Escenarios de aplicación del aprendizaje automático y el aprendizaje profundo
Clasificación de imágenes:
Usar modelos de aprendizaje automático o aprendizaje profundo para clasificar imágenes.
Escenarios de aplicación: clasificación de imágenes médicas, control de calidad industrial, etc.
Detección de objetos:
Usar modelos de aprendizaje profundo para detectar objetos en imágenes.
Escenarios de aplicación: conducción autónoma, vigilancia de seguridad, etc.
Segmentación semántica:
Usar modelos de aprendizaje profundo para clasificar cada píxel en una imagen.
Escenarios de aplicación: análisis de imágenes médicas, análisis de imágenes de teledetección, etc.
Algoritmos comunes de aprendizaje automático
OpenCV proporciona los siguientes algoritmos comunes de aprendizaje automático:
| Algoritmo | Descripción |
|---|---|
| KNN | Algoritmo de K vecinos más cercanos, utilizado para clasificación y regresión. |
| SVM | Máquina de vectores de soporte, utilizada para clasificación y regresión. |
| Árbol de decisión | Algoritmo de clasificación y regresión basado en estructura de árbol. |
| Bosque aleatorio | Algoritmo de aprendizaje conjunto basado en múltiples árboles de decisión. |
| K-Means | Algoritmo de agrupamiento, utilizado para dividir datos en varios grupos. |
Agrupamiento K-medias (K-Means)
El agrupamiento K-medias es un algoritmo de aprendizaje no supervisado que se utiliza principalmente para dividir un conjunto de datos en K grupos. Cada grupo está formado por las muestras más cercanas a su centro.
La idea central del algoritmo K-Means es optimizar iterativamente los centros de los grupos para minimizar la distancia entre cada muestra y el centro de su grupo correspondiente.
Pasos de implementación:
- Inicialización: seleccionar aleatoriamente K muestras como centros iniciales de los grupos.
- Asignación: asignar cada muestra al centro de grupo más cercano.
- Actualización: recalcular el centro de cada grupo.
- Iteración: repetir los pasos 2 y 3 hasta que los centros de los grupos ya no cambien o se alcance el número máximo de iteraciones.
K-Means en OpenCV:
Ejemplo
#include <iostream>
int main() {
// Generar algunos datos aleatorios
cv::Mat data(100, 2, CV_32F);
cv::randu(data, cv::Scalar(0, 0), cv::Scalar(100, 100));
// Establecer el valor de K y las condiciones de iteración
int K = 3;
cv::Mat labels, centers;
cv::kmeans(data, K, labels, cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::MAX_ITER, 10, 1.0), 3, cv::KMEANS_PP_CENTERS, centers);
// Mostrar el resultado
std::cout << "Labels: " << labels << std::endl;
std::cout << "Centers: " << centers << std::endl;
return 0;
}
En el código anterior, generamos 100 puntos de datos bidimensionales y usamos el algoritmo K-Means para dividirlos en 3 grupos.cv::kmeansLos parámetros de la función incluyen datos, número de grupos, etiquetas, condiciones de terminación, etc.
Máquinas de vectores de soporte (SVM)
La máquina de vectores de soporte (SVM) es un algoritmo de aprendizaje supervisado, utilizado principalmente para tareas de clasificación y regresión.
La idea central de SVM es encontrar un hiperplano que maximice el margen entre los puntos de muestra de diferentes clases.
Pasos de implementación:
- Entrenamiento: encontrar un hiperplano óptimo a través de los datos de entrenamiento.
- Predicción: usar el modelo entrenado para clasificar nuevos datos.
SVM en OpenCV:
Ejemplo
#include <iostream>
int main() {
// Generar algunos datos de entrenamiento
cv::Mat trainData = (cv::Mat_<float>(4, 2) << 1, 1, 1, 2, 2, 1, 2, 2);
cv::Mat labels = (cv::Mat_<int>(4, 1) << 1, 1, -1, -1);
// Crear el modelo SVM
cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
svm->setKernel(cv::ml::SVM::LINEAR);
svm->setType(cv::ml::SVM::C_SVC);
svm->setC(1);
// Entrenar el modelo
svm->train(trainData, cv::ml::ROW_SAMPLE, labels);
// Predecir nuevos datos
cv::Mat testData = (cv::Mat_<float>(1, 2) << 1.5, 1.5);
float response = svm->predict(testData);
std::cout << "Predicted label: " << response << std::endl;
return 0;
}
En el código anterior, usamos SVM para clasificar datos bidimensionales.
cv::ml::SVM::create()Se utiliza para crear el modelo SVM,trainel método se utiliza para entrenar el modelo,predictel método se utiliza para predecir la clase de nuevos datos.
Análisis de componentes principales (PCA)
El análisis de componentes principales (PCA) es una técnica de reducción de dimensionalidad, utilizada principalmente para reducir las dimensiones de un conjunto de datos mientras se conservan las características principales.
PCA mapea los datos originales a un nuevo sistema de coordenadas mediante una transformación lineal, de modo que la varianza de los datos en el nuevo sistema de coordenadas sea máxima.
Pasos de implementación:
- Calcular la matriz de covarianza: calcular la matriz de covarianza del conjunto de datos.
- Descomposición de valores propios: realizar la descomposición de valores propios de la matriz de covarianza para obtener vectores propios y valores propios.
- Selección de componentes principales: seleccionar los vectores propios correspondientes a los K valores propios más grandes como componentes principales.
- Proyección de datos: proyectar los datos originales sobre los componentes principales para obtener datos con dimensionalidad reducida.
PCA en OpenCV:
Ejemplo
#include <iostream>
int main() {
// Generar algunos datos
cv::Mat data = (cv::Mat_<float>(4, 2) << 1, 2, 2, 3, 3, 4, 4, 5);
// Crear el objeto PCA
cv::PCA pca(data, cv::Mat(), cv::PCA::DATA_AS_ROW, 1);
// Proyectar los datos
cv::Mat projected = pca.project(data);
std::cout << "Projected data: " << projected << std::endl;
return 0;
}
En el código anterior, usamos PCA para reducir la dimensionalidad de datos bidimensionales.cv::PCAEl constructor de la clase acepta los datos de entrada, el vector de medias, la disposición de los datos y el número de componentes principales a retener.projectEl método se utiliza para proyectar los datos sobre los componentes principales.
OpenCV y el aprendizaje profundo
Con la amplia aplicación del aprendizaje profundo en el campo de la visión por computadora, OpenCV también ha proporcionado soporte para el aprendizaje profundo.
A través del módulo DNN de OpenCV, los desarrolladores pueden cargar modelos de aprendizaje profundo preentrenados y realizar tareas como clasificación de imágenes, detección de objetos y segmentación semántica.
Cargar modelos de aprendizaje profundo preentrenados (módulo DNN)
El módulo DNN de OpenCV admite cargar modelos preentrenados de varios marcos de aprendizaje profundo (como TensorFlow, Caffe, PyTorch, etc.).
Con el módulo DNN, los desarrolladores pueden integrar fácilmente modelos de aprendizaje profundo en aplicaciones C++.
Cargar el modelo:
Ejemplo
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// Cargar el modelo Caffe preentrenado
cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "model.caffemodel");
// Verificar si el modelo se cargó correctamente
if (net.empty()) {
std::cerr << "Failed to load model!" << std::endl;
return -1;
}
std::cout << "Model loaded successfully!" << std::endl;
return 0;
}
En el código anterior, usamoscv::dnn::readNetFromCaffela función para cargar un modelo Caffe.deploy.prototxtEs el archivo de configuración del modelo,model.caffemodeles el archivo de pesos del modelo.
Clasificación de imágenes, detección de objetos, segmentación semántica
El módulo DNN de OpenCV admite varias tareas de aprendizaje profundo, incluyendo clasificación de imágenes, detección de objetos y segmentación semántica. A continuación, se muestra un ejemplo sencillo de clasificación de imágenes:
Clasificación de imágenes:
Ejemplo
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// Cargar el modelo Caffe preentrenado
cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "model.caffemodel");
// Cargar la imagen
cv::Mat image = cv::imread("image.jpg");
if (image.empty()) {
std::cerr << "Failed to load image!" << std::endl;
return -1;
}
// Preprocesar la imagen
cv::Mat blob = cv::dnn::blobFromImage(image, 1.0, cv::Size(224, 224), cv::Scalar(104, 117, 123));
// Establecer la entrada
net.setInput(blob);
// Propagación hacia adelante
cv::Mat prob = net.forward();
// Obtener el resultado de la clasificación
cv::Point classIdPoint;
double confidence;
cv::minMaxLoc(prob.reshape(1, 1), 0, &confidence, 0, &classIdPoint);
int classId = classIdPoint.x;
std::cout << "Class ID: " << classId << ", Confidence: " << confidence << std::endl;
return 0;
}
En el código anterior, cargamos un modelo Caffe y clasificamos la imagen de entrada.cv::dnn::blobFromImageLa función se utiliza para convertir la imagen al formato de entrada del modelo,net.forward()se utiliza para realizar la propagación hacia adelante,cv::minMaxLocse utiliza para obtener el resultado de la clasificación.
Usar OpenCV para ejecutar modelos como YOLO, SSD, etc.
El módulo DNN de OpenCV también admite la ejecución de modelos de detección de objetos como YOLO (You Only Look Once) y SSD (Single Shot MultiBox Detector).
A continuación, se muestra un ejemplo de detección de objetos usando el modelo YOLO:
Detección de objetos con YOLO:
Ejemplo
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// Cargar el modelo YOLO
cv::dnn::Net net = cv::dnn::readNetFromDarknet("yolov3.cfg", "yolov3.weights");
// Cargar la imagen
cv::Mat image = cv::imread("image.jpg");
if (image.empty()) {
std::cerr << "Failed to load image!" << std::endl;
return -1;
}
// Preprocesar la imagen
cv::Mat blob = cv::dnn::blobFromImage(image, 1/255.0, cv::Size(416, 416), cv::Scalar(0, 0, 0), true, false);
// Establecer la entrada
net.setInput(blob);
// Propagación hacia adelante
std::vector<cv::Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
// Analizar los resultados de la detección
for (size_t i = 0; i < outs.size(); ++i) {
float* data = (float*)outs[i].data;
for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols) {
cv::Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
cv::Point classIdPoint;
double confidence;
cv::minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
if (confidence > 0.5) {
int centerX = (int)(data[0] * image.cols);
int centerY = (int)(data[1] * image.rows);
int width = (int)(data[2] * image.cols);
int height = (int)(data[3] * image.rows);
int left = centerX - width / 2;
int top = centerY - height / 2;
cv::rectangle(image, cv::Point(left, top), cv::Point(left + width, top + height), cv::Scalar(0, 255, 0), 2);
}
}
}
// Mostrar el resultado
cv::imshow("Detection", image);
cv::waitKey(0);
return 0;
}
En el código anterior, cargamos un modelo YOLO y realizamos la detección de objetos en la imagen de entrada.cv::dnn::readNetFromDarknetLa función se utiliza para cargar el modelo YOLO,net.forwardse utiliza para realizar la propagación hacia adelante,cv::rectanglese utiliza para dibujar los cuadros de detección.