4. Erstellung der Anwendung in Visual Studio

In diesem Artikel wird die Struktur der Applikation erläutert. Der erforderliche Code wird Schritt für Schritt erarbeitet. Dabei werden die einzelnen Phasen, angefangen bei der Erstellung der App, über das Training des Models bis hin zur finalen Ausführung, detailliert beschrieben.

Sie können die Anleitung Schritt für Schritt durchgehen oder das Projekt bei GitHub herunterladen und in Visual Studio öffnen. Anhand der Anleitung können Sie den Aufbau und die Funktion der Applikation präzise nachvollziehen.

Schritt-für-Schritt-Anleitung

Projekteinstellungen:

1. Erstellen einer Windows Forms-Anwendung:

• Öffnen Sie Visual Studio.
• Wählen Sie “Neues Projekt erstellen”

• Wählen Sie “Windows Forms-Anwendung” und benennen Sie das Projekt “ProjektMaker_ObjektErkennung”.
• Wählen Sie als Zielframework .Net 7.0 aus.

3. Umbenennung von Form1.cs:

• Im Solution Explorer, Rechtsklick auf Form1.cs -> Umbenennen und ändern Sie den Namen in frmMain.cs.

4. Zusätzliche Nuget-Pakete Hinzufügen

• Microsoft.ML Paket dem Projekt
• Microsoft.ML.ImageAnalytics

Model Builder und Training:

1. Model Builder hinzufügen:

• Rechtsklick auf das Projekt in der Lösungs-Explorer.
• Wählen Sie “Hinzufügen” -> “Machine Learning”.

2. Objekterkennung in Model Builder:

• Im Model Builder, wählen Sie “Objekterkennung” als Szenario.

3. Umgebung (Trainingsumgebung bzw. Hardware) auswählen

• Wählen sie Lokal (CPU) aus.
• Steht eine Grafikkarte mit Unterstützung für Maschinelles Lernen bereit (CUDA Unterstützung), kann der Vorgang beschleunigt werden. Wählen Sie hierzu Lokal (GPU) aus.

4. Datensatz öffnen

• Unter Daten öffnen Sie den in VOTT exportieren Datensatz (JSON Datei)
• Klicken Sie auf “Train” und warten Sie, bis das Training abgeschlossen ist.

Je nach Leistungsfähigkeit des PC kann der Vorgang einige Zeit in Anspruch nehmen. Dies zeigt auch eines der Hauptprobleme des Maschinellen Lernens auf. Wird mit umfangreichen Datensätzen gearbeitet, ist ein Training ohne entsprechende Hardware (GPU – Unterstützung) kaum umsetzbar.

Im Projektmappen-Explorer sollte der Eintrag MLModelObj.mbconfig jetzt so aussehen.

5. Ergebnisse auswerten:

• Überprüfen Sie die Ergebnisse und die Genauigkeit des Modells in der Registerkarte “Auswerten”.
• Sie können das Fenster jetzt schließen, die weitere Arbeit findet im Code statt (frmMain.cs)

UI-Design und Code:

1. Button hinzufügen:

• Haben Sie den Designer geöffnet, ziehen Sie einen Button auf die Form und benennen Sie diesen in btnObjErkennung um.

2. Weiterer Button:

• Fügen Sie einen weiteren Button hinzu und benennen Sie ihn um in btnBildLaden.

3. Picturebox hinzufügen:

• Fügen Sie eine Picturebox hinzu, und setzen Sie die Eigenschaft SizeMode auf Zoom.

4. Code für Openfiledialog:

Mit einem Doppelklick auf den Button btnBildLaden wird ein neuer Codeblock btnBildLaden_Click automatisch erzeugt. Fügen sie den folgenden Code hinzu. Der Block sollte dann wie folgt aussehen:

private void btnBildLaden_Click(object sender, EventArgs e)

{

    // OpenFileDialog erstellen

    OpenFileDialog openFileDialog = new OpenFileDialog();

    // Filter auf Dateityp JPG

    openFileDialog.Filter = "JPG-Dateien (*.jpg;*.jpeg)|*.jpg;*.jpeg";

    // Nur ein Bild auswählbar

    openFileDialog.Multiselect = false;

    // Dialog anzeigen

    if (openFileDialog.ShowDialog() == DialogResult.OK)

    {

        // Bild laden

        Image image = Image.FromFile(openFileDialog.FileName);

        pictureBox1.ImageLocation = openFileDialog.FileName;

        // Bild in PictureBox anzeigen

        pictureBox1.Image = image;

    }

}

Code zum Laden des Modells und zur Objekterkennung:

Mit einem Doppelklick auf den Button btnObjErkennung wird ein neuer Codeblock btnObjErkennung_Click automatisch erzeugt. Fügen sie den folgenden Code hinzu. Der Block sollte dann wie folgt aussehen:

private void btnObjekterkennung_Click(object sender, EventArgs e)

 {

            Prediction();

 }

 Code zum Zeichnen der Boxen bei Erkennung von Objekten hinzufügen

private void Prediction()

        {

            if (!File.Exists(pictureBox1.ImageLocation))

            {

                MessageBox.Show("Bitte wählen Sie ein Bild aus!");

                return;

            }

            //Load sample data from pictureBox1 and convert to MLImage if is not null or empty

            var image = MLImage.CreateFromFile(pictureBox1.ImageLocation);

            MLModelObj.ModelInput sampleData = new MLModelObj.ModelInput()

            {

                Image = image,

            };

            ////Load model and predict output

            //log.AppendText("Model laden und Objecterkennung ausführen." + Environment.NewLine);

            var result = MLModelObj.Predict(sampleData);

            //log.AppendText("Prediction durchgeführt" + Environment.NewLine);

            //Messagebox with prediction result

            if (result.PredictedLabel == null || result.PredictedLabel.FirstOrDefault() == null)

            {

                MessageBox.Show("Es wurde kein Objekt erkannt!");

                return;

            }

            else

            {

                MessageBox.Show("Es wurde ein Objekt " + result.PredictedLabel.FirstOrDefault().ToString() + "mit einem Score: " + result.Score.FirstOrDefault().ToString() + " ermittelt.");

            }

            DrawBoxes(pictureBox1.Image, result, 0.45);

            pictureBox1.Invalidate();

        }

     

Code zum Zeichnen der Bounding-Boxen hinzufügen

//Zeichnen der Bounding-Boxen auf dem Image

        private static Image DrawBoxes(Image img, ModelOutput output, double threshold)

        {

            using (Graphics g = Graphics.FromImage(img))

            {

                // Erstellen Sie einen roten Stift zum Zeichnen der Begrenzungsrahmen

                using (Pen pen = new Pen(Color.Yellow, 3))

                {

                    {

                        // Iterieren Sie über alle vorhergesagten Begrenzungsrahmen

                        for (int i = 0; i < output.PredictedBoundingBoxes.Length; i += 4)

                        {

                            // Extrahieren Sie die Koordinaten des Begrenzungsrahmens

                            float x = output.PredictedBoundingBoxes[i];

                            float y = output.PredictedBoundingBoxes[i + 1];

                            float width = output.PredictedBoundingBoxes[i + 2] - x;

                            float height = output.PredictedBoundingBoxes[i + 3] - y;

                            // Extrahieren Sie den Score und das Label für diese Vorhersage

                            float score = output.Score[i / 4];

                            string label = output.PredictedLabel[i / 4];

                            // Zeichnen Sie den Begrenzungsrahmen und beschriften Sie ihn, wenn der Score größer als 45% ist

                            if (score > threshold)

                            {

                                g.DrawRectangle(pen, x, y, width, height);

                                g.DrawString($"{label}: {score:P1}", new Font("Arial", 10), Brushes.Red, new PointF(x, y));

                            }

                        }

                    }

                }

            }

            return img;

        }

       

Die Anwendung ist jetzt vollständig erstellt. Ordnen Sie die einzelnen Elemente nach Belieben an und nutzen Sie auch die “Anchor”-Eigenschaft der Elemente, damit diese bei einer Größenänderung des Fensters automatisch positioniert und bei Bedarf an die Größe angepasst werden.

Kurzfassung:

Mit dieser Anwendung können Benutzer ein Bild über den Button btnBildLaden öffnen, welches dann in der PictureBox angezeigt wird. Durch Klicken auf den Button btnObjErkennung wird das trainierte Modell geladen, und die Objekterkennung auf dem geladenen Bild ausgeführt. Obwohl die spezifischen Ergebnisse der Objekterkennung von dem trainierten Modell und den bereitgestellten Daten abhängen, sollte die Anwendung in der Lage sein, erkannte Objekte im Bild zu identifizieren und dem Benutzer entsprechend Feedback zu geben.

Starten der Anwendung und Prüfen der Funktion (Debuggen)

Wir können die Anwendung jetzt testen. Dazu ist zunächst ein Bild zu öffnen und dann die Objekterkennung auszuführen. Achten Sie darauf, dass Sie kein Bild verwenden, womit das Model trainiert wurde. Die Anwendung könnte jetzt wie folgendermaßen aussehen.

Die Erkennungsrate hängt insbesondere von den Trainingsdaten ab. Achten Sie darauf, bei der Erstellung des Datensatzes darauf akkurat zu arbeiten und einen möglichst umfangreichen Datensatz zu erstellen.

Zusammenfassung:

Die Anleitung beschreibt die Erstellung einer Windows Forms-Anwendung unter Verwendung von .NET 7.0 für eine Objekterkennungsanwendung. Angefangen beim Setup des Projekts, über das Hinzufügen des Model Builders, das Laden eines VOTT-Datensatzes, das Starten des Trainings bis hin zur Auswertung der Ergebnisse und dem Design der Benutzeroberfläche mit Buttons und einer PictureBox. Der Code ermöglicht es dem Benutzer, ein Bild zu laden und eine Objekterkennung durchzuführen. Durch die Umsetzung dieser Schritte entsteht eine funktionelle Anwendung zur Objekterkennung, die Benutzern ermöglicht, Bilder zu analysieren und erkannte Objekte zu identifizieren.

Das ganze Projekt gibt es zum Download auf GitHub:

Weiter geht es mit Teil 6…

Überblick:

Teil 1 – Teil 2 – Teil 3 – Teil 4 – Teil 5

Das Projekt zum Download auf GitHub.