C++ OpenCV Maschinelles Lernen und Deep Learning
OpenCV unterstützt nicht nur traditionelle Computer-Vision-Aufgaben, sondern bietet auch umfangreiche Funktionen für maschinelles Lernen und Deep Learning, mit denen komplexe Aufgaben wie Bildklassifizierung, Objekterkennung und semantische Segmentierung realisiert werden können.
Maschinelles Lernen: OpenCV bietet eine Vielzahl traditioneller Algorithmen für maschinelles Lernen wie KNN, SVM, Entscheidungsbäume usw.
Deep Learning: Das DNN-Modul von OpenCV unterstützt das Laden und Ausführen vortrainierter Deep-Learning-Modelle (wie TensorFlow, PyTorch, Caffe usw.)
Anwendungsszenarien für maschinelles Lernen und Deep Learning
Bildklassifizierung:
Verwenden Sie Modelle für maschinelles Lernen oder Deep Learning, um Bilder zu klassifizieren.
Anwendungsszenarien: medizinische Bildklassifizierung, industrielle Qualitätsprüfung usw.
Objekterkennung:
Verwenden Sie Deep-Learning-Modelle, um Objekte in Bildern zu erkennen.
Anwendungsszenarien: autonomes Fahren, Sicherheitsüberwachung usw.
Semantische Segmentierung:
Verwenden Sie Deep-Learning-Modelle, um jedes Pixel in einem Bild zu klassifizieren.
Anwendungsszenarien: medizinische Bildanalyse, Fernerkundungs-Bildanalyse usw.
Gängige Algorithmen für maschinelles Lernen
OpenCV bietet die folgenden gängigen Algorithmen für maschinelles Lernen:
| Algorithmus | Beschreibung |
|---|---|
| KNN | K-Nearest-Neighbors-Algorithmus, verwendet für Klassifikation und Regression. |
| SVM | Support Vector Machine, verwendet für Klassifikation und Regression. |
| Entscheidungsbaum | Ein baumbasierter Klassifikations- und Regressionsalgorithmus. |
| Random Forest | Ein Ensemble-Lernalgorithmus, der auf mehreren Entscheidungsbäumen basiert. |
| K-Means | Clustering-Algorithmus, verwendet, um Daten in mehrere Cluster zu unterteilen. |
K-Means-Clustering
K-Means-Clustering ist ein unüberwachter Lernalgorithmus, der hauptsächlich verwendet wird, um einen Datensatz in K Cluster zu unterteilen. Jeder Cluster besteht aus den Stichproben, die seinem Mittelpunkt am nächsten liegen.
Die Kernidee des K-Means-Algorithmus besteht darin, die Cluster-Zentren iterativ zu optimieren, sodass der Abstand jedes Stichprobenpunkts zu seinem Cluster-Zentrum minimiert wird.
Implementierungsschritte:
- Initialisierung: Zufällige Auswahl von K Stichproben als anfängliche Cluster-Zentren.
- Zuordnung: Jede Stichprobe dem nächstgelegenen Cluster-Zentrum zuweisen.
- Aktualisierung: Den Mittelpunkt jedes Clusters neu berechnen.
- Iteration: Wiederholen Sie die Schritte 2 und 3, bis sich die Cluster-Zentren nicht mehr ändern oder die maximale Anzahl an Iterationen erreicht ist.
K-Means in OpenCV:
Beispiel
#include <iostream>
int main() {
// Einige Zufallsdaten generieren
cv::Mat data(100, 2, CV_32F);
cv::randu(data, cv::Scalar(0, 0), cv::Skalar(100, 100));
// K-Wert und Iterationsbedingungen festlegen
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);
// Ergebnisse ausgeben
std::cout << "Beschriftungen: " << labels << std::endl;
std::cout << "Zentren: " << centers << std::endl;
return 0;
}
Im obigen Code haben wir 100 zweidimensionale Datenpunkte erzeugt und den K-Means-Algorithmus verwendet, um sie in 3 Cluster aufzuteilen.cv::kmeansDie Parameter der Funktion umfassen die Daten, die Anzahl der Cluster, Labels, Abbruchbedingungen usw.
Support-Vektor-Maschine (SVM)
Support Vector Machine (SVM) ist ein überwachter Lernalgorithmus, der hauptsächlich für Klassifikations- und Regressionsaufgaben verwendet wird.
Die Kernidee von SVM besteht darin, eine Hyperebene zu finden, die den Margin zwischen den Beispielpunkten verschiedener Klassen maximiert.
Implementierungsschritte:
- Training: Eine optimale Hyperebene anhand der Trainingsdaten finden.
- Vorhersage: Verwende das trainierte Modell, um neue Daten zu klassifizieren.
SVM in OpenCV:
Beispiel
#include <iostream>
int main() {
// Trainingsdaten generieren
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);
// Ein SVM-Modell erstellen
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);
// Das Modell trainieren
svm->train(trainData, cv::ml::ROW_SAMPLE, labels);
// Neue Daten vorhersagen
cv::Mat testData = (cv::Mat_<float>(1, 2) << 1.5, 1.5);
float response = svm->predict(testData);
std::cout << "Vorhergesagtes Label: " << response << std::endl;
return 0;
}
Im obigen Code verwenden wir SVM, um zweidimensionale Daten zu klassifizieren.
cv::ml::SVM::create()Wird verwendet, um das SVM-Modell zu erstellen,trainDie Methode wird verwendet, um das Modell zu trainieren,predictDie Methode wird verwendet, um die Klasse neuer Daten vorherzusagen.
Hauptkomponentenanalyse (PCA)
Die Hauptkomponentenanalyse (PCA) ist eine Technik zur Dimensionsreduktion, die hauptsächlich verwendet wird, um die Dimensionalität eines Datensatzes zu reduzieren und dabei die Hauptmerkmale der Daten beizubehalten.
PCA bildet die Originaldaten durch eine lineare Transformation auf ein neues Koordinatensystem ab, sodass die Varianz der Daten im neuen Koordinatensystem maximiert wird.
Implementierungsschritte:
- Kovarianzmatrix berechnen: Berechnen Sie die Kovarianzmatrix des Datensatzes.
- Eigenwertzerlegung: Führen Sie eine Eigenwertzerlegung der Kovarianzmatrix durch, um Eigenvektoren und Eigenwerte zu erhalten.
- Hauptkomponenten auswählen: Wählen Sie die Eigenvektoren aus, die den K größten Eigenwerten entsprechen, als Hauptkomponenten.
- Datenprojektion: Projizieren Sie die Originaldaten auf die Hauptkomponenten, um die Daten mit reduzierter Dimensionalität zu erhalten.
PCA in OpenCV:
Beispiel
#include <iostream>
int main() {
// Einige Daten generieren
cv::Mat data = (cv::Mat_<float>(4, 2) << 1, 2, 2, 3, 3, 4, 4, 5);
// Ein PCA-Objekt erstellen
cv::PCA pca(data, cv::Mat(), cv::PCA::DATA_AS_ROW, 1);
// Daten projizieren
cv::Mat projected = pca.project(data);
std::cout << "Projizierte Daten: " << projected << std::endl;
return 0;
}
Im obigen Code verwenden wir PCA, um die Dimensionalität zweidimensionaler Daten zu reduzieren.cv::PCADer Klassenkonstruktor akzeptiert Eingabedaten, Mittelwertvektor, Datenlayout und die Anzahl der beibehaltenen Hauptkomponenten.projectDie Methode wird verwendet, um die Daten auf die Hauptkomponenten zu projizieren.
OpenCV und Deep Learning
Mit der breiten Anwendung von Deep Learning im Bereich der Computer Vision bietet OpenCV auch Unterstützung für Deep Learning.
Über das DNN-Modul von OpenCV können Entwickler vortrainierte Deep-Learning-Modelle laden und Aufgaben wie Bildklassifizierung, Objekterkennung und semantische Segmentierung ausführen.
Laden vortrainierter Deep-Learning-Modelle (DNN-Modul)
Das DNN-Modul von OpenCV unterstützt das Laden vortrainierter Modelle aus mehreren Deep-Learning-Frameworks (wie TensorFlow, Caffe, PyTorch usw.).
Über das DNN-Modul können Entwickler Deep-Learning-Modelle einfach in C++-Anwendungen integrieren.
Laden des Modells:
Beispiel
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// Laden Sie ein vortrainiertes Caffe-Modell
cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "model.caffemodel");
// Überprüfen, ob das Modell erfolgreich geladen wurde
if (net.empty()) {
std::cerr << "Modell konnte nicht geladen werden!" << std::endl;
return -1;
}
std::cout << "Modell erfolgreich geladen!" << std::endl;
return 0;
}
Im obigen Code verwenden wircv::dnn::readNetFromCaffedie Funktion zum Laden eines Caffe-Modells.deploy.prototxtist die Modellkonfigurationsdatei,model.caffemodelist die Gewichtsdatei des Modells.
Bildklassifizierung, Objekterkennung, semantische Segmentierung
Das DNN-Modul von OpenCV unterstützt mehrere Deep-Learning-Aufgaben, darunter Bildklassifizierung, Objekterkennung und semantische Segmentierung. Das Folgende ist ein einfaches Beispiel für die Bildklassifizierung:
Bildklassifizierung:
Beispiel
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// Laden Sie ein vortrainiertes Caffe-Modell
cv::dnn::Net net = cv::dnn::readNetFromCaffe("deploy.prototxt", "model.caffemodel");
// Das Bild laden
cv::Mat image = cv::imread("image.jpg");
if (image.empty()) {
std::cerr << "Bild konnte nicht geladen werden!" << std::endl;
return -1;
}
// Das Bild vorverarbeiten
cv::Mat blob = cv::dnn::blobFromImage(image, 1.0, cv::Size(224, 224), cv::Skalar(104, 117, 123));
// Die Eingabe festlegen
net.setInput(blob);
// Vorwärtspropagierung
cv::Mat prob = net.forward();
// Das Klassifizierungsergebnis abrufen
cv::Point classIdPoint;
double confidence;
cv::minMaxLoc(prob.reshape(1, 1), 0, &confidence, 0, &classIdPoint);
int classId = classIdPoint.x;
std::cout << "Klassen-ID: " << classId << ", Konfidenz: " << confidence << std::endl;
return 0;
}
Im obigen Code haben wir ein Caffe-Modell geladen und das Eingabebild klassifiziert.cv::dnn::blobFromImageDie Funktion wird verwendet, um das Bild in das Eingabeformat des Modells umzuwandeln,net.forward()wird verwendet, um die Vorwärtspropagierung durchzuführen,cv::minMaxLocwird verwendet, um das Klassifizierungsergebnis zu erhalten.
Ausführen von Modellen wie YOLO und SSD mit OpenCV
Das DNN-Modul von OpenCV unterstützt auch das Ausführen von Objekterkennungsmodellen wie YOLO (You Only Look Once) und SSD (Single Shot MultiBox Detector).
Das folgende ist ein Beispiel für die Verwendung des YOLO-Modells zur Objekterkennung:
YOLO-Objekterkennung:
Beispiel
#include <opencv2/dnn.hpp>
#include <iostream>
int main() {
// YOLO-Modell laden
cv::dnn::Net net = cv::dnn::readNetFromDarknet("yolov3.cfg", "yolov3.weights");
// Das Bild laden
cv::Mat image = cv::imread("image.jpg");
if (image.empty()) {
std::cerr << "Bild konnte nicht geladen werden!" << std::endl;
return -1;
}
// Das Bild vorverarbeiten
cv::Mat blob = cv::dnn::blobFromImage(image, 1/255.0, cv::Size(416, 416), cv::Scalar(0, 0, 0), true, false);
// Die Eingabe festlegen
net.setInput(blob);
// Vorwärtspropagierung
std::vector<cv::Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
// Erkennungsergebnisse parsen
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::Skalar(0, 255, 0), 2);
}
}
}
// Ergebnisse anzeigen
cv::imshow("Erkennung", image);
cv::waitKey(0);
return 0;
}
Im obigen Code haben wir ein YOLO-Modell geladen und eine Objekterkennung auf dem Eingabebild durchgeführt.cv::dnn::readNetFromDarknetDie Funktion wird zum Laden des YOLO-Modells verwendet,net.forwardwird verwendet, um die Vorwärtspropagierung durchzuführen,cv::rectanglewird zum Zeichnen von Erkennungsboxen verwendet.