OpenFarmingAI: Basilikumblätter-Instanzsegmentierung Mit Mask-RCNN Und Telegram-Bot

Im Rahmen des vom BMBF geförderten Projektes "OpenFarmingAI" mit dem Förderkennzeichen 13N15386 durchgeführt.

Im OpenFarmingAI (OFAI) Projekt steht die Anwendung von künstlicher Intelligenz im Bereich der Pflanzenerkennung und -analyse im Fokus. Ziel des Projekts ist es, Pflanzenzustände präzise zu identifizieren, um optimale Wachstumsbedingungen zu gewährleisten und Probleme frühzeitig zu erkennen. In diesem Instructable werden wir den Fortschritt des OFAI-Projekts, die verschiedenen Ansätze zur Pflanzenzustandsanalyse und die erfolgreiche Implementierung eines Mask-RCNN-Modells zur Instanzsegmentierung von Basilikumblättern erläutern.

Zu Beginn des Projekts wurde ein Keras-basiertes Modell entwickelt, das auf dem Plantvillage-Datensatz (Link) trainiert wurde und eine Präzision von über 98 % erreichte. Als das Modell jedoch auf unseren eigenen Datensatz von ca. 600 Bildern gesunden und welken Basilikums angewendet wurde, zeigten die Ergebnisse eine unzureichende Leistung. Durch eine Analyse der Visualisierung der einzelnen Layer wurde festgestellt, dass das Modell dazu neigte, sich auf den Hintergrund der Bilder zu konzentrieren. Daher wurde entschieden, einen anderen Ansatz zu wählen: Die Instance Segmentation mittels Mask-RCNN. Diese Methode ermöglicht es, den Fokus auf die relevanten Objekte im Bild, in diesem Fall die Basilikumblätter, zu legen und den Hintergrund zu ignorieren.

In diesem Instructable werden wir Schritt für Schritt erklären, wie das Mask-RCNN-Modell entwickelt, trainiert und in einen Telegram-Bot integriert wurde. Dies ermöglicht es Benutzern, den Bot zur Analyse von Basilikumblättern zu verwenden und die Ergebnisse der Instanzsegmentierung zu erhalten. Darüber hinaus werden wir die Datenerfassung und -annotation sowie die Integration von zusätzlichen Daten in das Modell besprechen.

Da wir auch für die Instanzsegmentierung verhältnismäßig wenige Daten hatten und die Segmentierung viel Zeit in Anspruch nimmt, haben wir für das Training Blattkollagen als Data Augmentation Strategie erstellt (Quelle). Dies erhöht künstlich die Anzahl an zur Verfügung stehenden Trainingsdaten.

Begleitet uns auf dieser Reise, um mehr über künstliche Intelligenz in der Pflanzenanalyse zu erfahren und wie ihr OpenFarmingAI nutzen können, um den Zustand eurer eigenen Pflanzen zu überwachen und zu optimieren.

• Hard- und Software
• Computer
• Kamera (auch Smartphone-Kamera)
• Visual Studio Code
• Python v.3.10.7
• Kaggle Account
• Docker
• Git
• Grundkenntnisse in KI, Python und Telegram-Bots
• Daten, Repositories und Notebooks:
• Basilikum-Datensatz (Link und Link)
• Mask-RCNN-Klon (Link)
• Kaggle Training-Notebook (Link)

In diesem Schritt erfahrt ihr, wie ihr das OpenFarmingAI-Repository von GitHub klont und die erforderlichen Bibliotheken und Abhängigkeiten installiert. Das Repository beinhaltet sowohl die grafische Benutzeroberfläche (GUI) als auch das angepasste Mask-RCNN-Modell. Ihr könnt das Training lokal oder online in einem Kaggle-Notebook durchführen.

• Klont das OpenFarmingAI-Repository von GitHub: Öffnet ein Terminalfenster (oder eine Eingabeaufforderung unter Windows) und führt den folgenden Befehl aus, um das Repository auf eurem Computer zu klonen:

bash
git clone https://github.com/protohaus/mask-rcnn.git C:\path\on\your\computer\

Wechselt in den mask-rcnn-Ordner:

bash
cd C:\path\on\your\computer\mask-rcnn

Installiert die erforderlichen Bibliotheken und Abhängigkeiten:

pip install -r requirements.txt

• Ladet das aktuelle Mask-RCNN-Modell herunter: Das aktuelle Modell findet sich in den Releases des GitHub-Repositories. Navigiert zu den Releases, wählt die gewünschte Version des Modells und ladet es herunter. Speichert das Modell im "mask-rcnn"-Ordner.

Für ein lokales Training sollte eine NVIDA Grafikkarte mit ausreichend Speicher zur Verfügung stehen sowie Cuda & cuCDNN installiert werden (Link).

Nachdem ihr das Repository geklont und die erforderlichen Bibliotheken und Abhängigkeiten installiert habt, könnt ihr mit dem Training des Mask-RCNN-Modells beginnen, entweder lokal oder in einem Kaggle-Notebook (siehe spätere Schritte).

Datenerfassung: Die Qualität der Datenerfassung ist entscheidend für ein erfolgreiches Training des KI-Modells. Um hochwertige Bilder für das Training zu erhalten, solltet ihr bei der Aufnahme der Fotos einige wichtige Punkte beachten:

1. Stellt sicher, dass die Pflanze komplett fokussiert ist und verschiedene Pflanzen sich nach Möglichkeit nicht überlappen.
2. Versucht, eine Vielzahl von Hintergründen und Beleuchtungsszenarien abzudecken, um die KI robuster gegenüber unterschiedlichen Umgebungen zu machen.
3. Achtet darauf, für jede gewünschte Kategorie eine ausgewogene Anzahl von Bildern aufzunehmen, z. B. Thai-Basilikum welk und gesund oder Genovese gesund, welk und von Blattläusen befallen, usw. Eine Pflanzenart mit einem Pflanzenzustand ist dabei eine Kategorie. Also z.B.: Kategorie 1: Genovese, gesund; Kategorie 2: Genovese, welk; etc.

Datenerfassung ist ein iterativer Prozess, und es ist wichtig, ständig zu prüfen, ob die Bilder den Anforderungen entsprechen, um das KI-Modell optimal zu trainieren.

Für das spätere Training macht es Sinn, auch einige neutrale Bilder ohne Pflanzen aufzunehmen.

Sobald die Bilder aufgenommen wurden, ist der nächste Schritt, sie mit dem VIA (VGG Image Annotator) Tool zu annotieren. Achtet darauf, die VIA-Version 2.0.11 zu verwenden. Befolgt die folgenden Schritte, um die Bilder mit VIA zu annotieren:

1. Ladet das VIA Tool Version 2.0.11 von der offiziellen Webseite herunter und entpackt die Dateien in einen Ordner Ihrer Wahl.
2. Öffnet die Datei "via.html" mit einem Webbrowser, um das VIA Tool in eurem Browser zu starten.
3. Klickt auf "Project" und dann auf "Add Files", um die aufgenommenen Bilder in das Tool zu importieren.
4. Klickt auf "Project" und dann auf "Import region/attribute file" und wählt die "Basil_Dataset_attributes.json"-Datei aus, die die Kategorien und Attribute für die Annotationen enthält.
5. (optional) Importiert segmentierte Regionen aus einer früheren Session über "Annotations" --> "Import Annotations from json" und wählt eine "via_region_annotation.json" aus.

Nachdem die Bilder importiert wurden und die "Basil_Dataset_attributes.json"-Datei geöffnet ist, könnt ihr mit der Segmentierung der Basilikumblätter beginnen:

1. Wählt das Polygon-Werkzeug (Shortcut: F4) aus der Werkzeugleiste.
2. Vergrößert das Bild auf 5x oder 6x, um die Segmentierung zu erleichtern.
3. Klickt entlang der Konturen jedes Blattes, um ein Polygon zu erstellen, das das gesamte Blatt einschließlich des Blattrandes erfasst. Achtet darauf, das Blatt nicht abzuschneiden und gleichzeitig so wenig Hintergrund wie möglich zu zeigen.

Nachdem alle Blätter auf den Bildern segmentiert wurden, speichert die Annotationen und exportiert sie im JSON-Format:

1. Klickt auf "Annotations" in der oberen rechten Ecke des VIA-Tools.
2. Wählt "Export Annotations (as json)" und speicht die JSON-Datei an einem geeigneten Ort.

Diese JSON-Datei kann später beim Training des Mask-RCNN-Modells verwendet werden.

Um die besten Blätter für die Erstellung von Blattkollagen auszuwählen, könnt ihr die im OpenFarmingAI-Repository bereitgestellte GUI verwenden. Die GUI ist in der Datei "tkgui.py" enthalten und kann am besten über Visual Studio Code aufgerufen werden. Befolgt die folgenden Schritte, um die besten Blätter auszuwählen:

1. Öffnet Visual Studio Code und navigiert zum OpenFarmingAI-Ordner.
2. Öffnet die Datei "tkgui.py" und führt sie aus, um die GUI zu starten.
3. In der GUI wählt zunächst im Reiter "Raw Data" den Ordner aus, der die Bilder mit den Basilikumblättern enthält.
4. Wechselt zum Reiter "Segmentation" und wählt die JSON-Datei aus, die die Annotationsdaten aus Schritt 1 enthält.
5. Legt einen Output-Ordner fest, in dem die ausgewählten Blätter gespeichert werden sollen.
6. Klickt auf die Schaltfläche "Start Organizer", um zur Organizer-Ansicht zu wechseln.
7. Klickt auf "Start" und beginnt damit, die vorgeschlagenen Blätter in die Kategorien "healthy" (gesund) und "withered" (welk) zu sortieren. Verwendet die Kategorie "Discard", um Blätter auszuschließen, die nicht für die Kollagen verwendet werden sollen.
8. Achtet darauf, nur Blätter auszuwählen, die vollständig und hochauflösend sind, um die Qualität der Kollagen zu gewährleisten.

Sobald ihr die Blätter in die entsprechenden Kategorien "healthy", "withered" und "Discard" sortiert habt, müsst ihr sie speichern. Dies kann auf zwei Arten geschehen:

1. Manuelles Speichern: Klickt auf den "Save"-Button in der GUI, um die kategorisierten Blätter manuell zu speichern. Dadurch werden die ausgewählten Blätter im zuvor festgelegten Output-Ordner gespeichert.
2. Automatisches Speichern: Wenn ihr alle Blätter aus der Annotations-Datei kategorisiert habt, werden sie automatisch im Output-Ordner gespeichert.

Durch das Speichern der kategorisierten Blätter stellt ihr sicher, dass die ausgewählten gesunden und welken Basilikumblätter für die Erstellung von Blattkollagen im nächsten Schritt verwendet werden können. Die Blätter, die in die Kategorie "Discard" sortiert wurden, werden nicht für die Kollagen verwendet und können bei Bedarf für zukünftige Projekte oder Analysen aufbewahrt werden.

In diesem Schritt verwendet ihr das in der GUI integrierte Programm, um aus den ausgewählten Basilikumblättern aus Schritt 4 und einer Reihe von neutralen Hintergründen Blattkollagen zu erstellen. Diese Kollagen dienen als Trainings- und Validierungsdaten für das Mask-RCNN-Modell.

1. Öffnet die GUI, falls noch nicht geschehen, und wechsel zum Reiter "Collage Creation".
2. Gebt den Pfad zu den neutralen Hintergründen an, die ihr für die Erstellung der Kollagen verwenden möchtet.
3. Gebt den Pfad zum Output-Ordner an, in dem die erstellten Kollagen gespeichert werden sollen.
4. Legt die Anzahl der gewünschten Blattkollagen fest. Beachtet, dass der Train-Val-Split 80:20 beträgt. Wenn ihr beispielsweise 200 Kollagen auswählt, werden 200 Trainingsbilder und 50 zusätzliche Validierungsbilder erstellt. Die maximale Auflösung einer Kantenlänge der Bilder beträgt 1411 Pixel.
5. Klickt auf die Schaltfläche "Start Collage Creation", um den Prozess der Kollagenerstellung zu starten.

Der Algorithmus erstellt daraufhin Blattkollagen, indem er zufällig ausgewählte Blätter verwendet, die zufällig rotiert, skaliert und geschert werden. Zusätzlich werden die Farbinformationen der Blätter randomisiert, um die Vielfalt der Trainings- und Validierungsdaten zu erhöhen.

Nach Abschluss der Kollagenerstellung habt ihr eine Reihe von Trainings- und Validierungsdaten, die ihr für das Training des Mask-RCNN-Modells verwenden könnt. Der nächste Schritt besteht darin, das Modell mit diesen Daten zu trainieren und seine Leistung zu bewerten.

Bei der Erstellung von Blattkollagen für das Training des Mask-RCNN-Modells ist es wichtig, die Anzahl der Bilddaten an die Fähigkeiten der GPU des Trainingsrechners anzupassen. Die richtige Menge an Bilddaten hängt von der verfügbaren GPU-Leistung ab und kann die Trainingsgeschwindigkeit und -effizienz beeinflussen.

Wenn ihr das Training auf einer Kaggle-GPU durchführt, hat sich eine Anzahl von 200 Trainingsbildern als effektiv erwiesen. Dies bietet eine ausreichende Menge an Trainingsdaten, um ein leistungsfähiges Modell zu trainieren, ohne die GPU-Kapazität zu überlasten oder die Trainingszeit unnötig zu verlängern.

Um die optimale Anzahl von Trainingsbildern für Ihre spezifische GPU-Kapazität zu bestimmen, könnt ihr verschiedene Mengen an Trainingsbildern ausprobieren und die Auswirkungen auf die Trainingsgeschwindigkeit und -leistung beobachten. Passt die Anzahl der Bilder im Schritt 5 der GUI entsprechend an, bevor ihr die Kollagen erstellt.

Um ein vorhandenes Modell um eine weitere Klasse zu erweitern, müsst ihr an mehreren Stellen im Repository Änderungen vornehmen. Hier sind die notwendigen Schritte, um eine neue Kategorie hinzuzufügen:

• Fügt die entsprechende Kategorie in die "Basil_Dataset_attributes.json" Datei ein.
• Erweitert die GUI zur Erstellung der Blattkollagen um die entsprechende Kategorie. Öffnet die Datei "tkgui.py" und sucht die Klasse class PageLeafOrganizer(tk.Frame). Fügt ab Zeile 149 einen neuen Button für die neue Klasse hinzu, ähnlich wie die vorhandenen Buttons für "healthy" und "withered":

python
self.newClassButton = ttk.Button(self, text = "newClass", command = lambda: self.process_input(True,'newClass'))
self.newClassButton.grid(row = 6, column = 1)
self.newClassButton['state'] = tk.DISABLED

Vergesst nicht, den Button und den Text entsprechend der neuen Klasse anzupassen.

• Erweitert die export_leafs Funktion um eine weitere Kategorie. Fügt den entsprechenden Codeblock hinzu, um die Blätter der neuen Kategorie in einen separaten Ordner zu speichern:

python
newClassPath = os.path.join(path_leafoutput.get(), 'newClass')
if not os.path.exists(newClassPath):
    os.makedirs(newClassPath)

# ...

if self.jsonObject[key]["regions"][index]["region_attributes"]["State"] == "newClass":
    leaf["image"].save(os.path.join(newClassPath, 'IMG_{0}_ROI_mask_{1}.png'.format(filename, index)))

Ersetzt "newClass" durch den Namen der neuen Kategorie.

Ihr solltet auch die folgenden Funktionen erweitern, um die neue Kategorie zu berücksichtigen:

• In der save_json Funktion, fügt den entsprechenden Codeblock hinzu, um den Button der neuen Klasse zu deaktivieren:

python
def save_json(self):
    # ...
    self.newClassButton['state'] = tk.DISABLED
    # ...

Ersetzt "newClassButton" durch den Namen des Buttons, den ihr für die neue Klasse erstellt habt.

• In der start_organizer Funktion, aktiviert den Button der neuen Klasse:

python
def start_organizer(self):
    # ...
    self.newClassButton['state'] = tk.NORMAL
    # ...

Ersetzt "newClassButton" durch den Namen des Buttons, den ihr für die neue Klasse erstellt habt.

Nachdem ihr diese Änderungen vorgenommen habt, sollte die GUI in der Lage sein, die neue Kategorie sowohl beim Start des Organizers als auch beim Speichern der JSON-Datei und der Blattbilder zu berücksichtigen.

Um die Datei CreateCollages.py an die neue Kategorie anzupassen, müsst ihr die Kategorie in den relevanten Teilen der Funktion create_collages hinzufügen. Hier sind die Schritte, um dies zu tun:

• Fügt den Pfad zur neuen Kategorie dem leaf_images Dictionary hinzu. Zum Beispiel, wenn eure neue Kategorie "new_class" heißt, fügt die folgende Zeile nach der Erstellung von leaf_images hinzu:

python
leaf_images = {'healthy':[],'withered':[], 'new_class':[]}

• Ladet die Bilder der neuen Kategorie und fügt sie dem leaf_images Dictionary hinzu. Ihr könnt den folgenden Codeblock als Vorlage verwenden und anpassen:

python
new_class_path = os.path.join(LEAF_FOLDER,'new_class')
if not os.path.exists(new_class_path):
    print("New class Leaf folder not existing...")
    return

for image in os.listdir(new_class_path):
    if image.lower().endswith('.png'):
        leaf_image = cv2.imread(os.path.join(new_class_path,image),flags=cv2.IMREAD_UNCHANGED)
        new_width = int(leaf_image.shape[1] * scale_percent_leafs / 100)
        new_height = int(leaf_image.shape[0] * scale_percent_leafs / 100)
        dim = (new_width, new_height)

        resized = cv2.resize(leaf_image, dim, interpolation = cv2.INTER_NEAREST)
        leaf_images['new_class'].append(resized)
    else:
        print("Found non-png type in folder.")
if len(leaf_images['new_class']) == 0:
    print("Loaded 0 leaf images")
    return

• In der for-Schleife, die zufällig Blätter auswählt und sie auf dem Hintergrundbild platziert, ändert die category Variable, um auch die neue Kategorie zu berücksichtigen. Zum Beispiel, wenn eure neue Kategorie "new_class" ist, ändert die Zeile:

python
category = random.randint(1,2)

in

python
category = random.randint(1,3)

und fügt den entsprechenden Codeblock hinzu, um die neue Kategorie zu berücksichtigen:

python
if category == 3:
    key = 'new_class'

• In der Schleife, die die Masken erstellt, fügt den entsprechenden Codeblock hinzu, um die neue Kategorie zu berücksichtigen. Zum Beispiel, wenn eure neue Kategorie "new_class" ist und der entsprechende Farbwert 3 ist, fügt den folgenden Codeblock hinzu:

python
if color[2] == 3:
    state = 'new_class'

Nachdem ihr diese Änderungen vorgenommen habt, sollte die create_collages Funktion in der Lage sein, die neue Kategorie zu berücksichtigen und Blattkollagen mit der neuen Kategorie zu erstellen.

Um die neue Kategorie in der Datei /samples/leafs_collage/leafs_collage.py einzubinden, müsst ihr die folgenden Änderungen vornehmen:

• Ändert die Zeile 77 in NUM_CLASSES = 1 + 3, um der zusätzlichen Kategorie gerecht zu werden.
• Fügt der Klasse LeafsCollageDataset eine neue Kategorie hinzu. Ändert dazu den Code ab Zeile 144 wie folgt:

python
class LeafsCollageDataset(utils.Dataset):
    def load_leafs(self, dataset_dir, subset):
        """Load a subset of the basil leafs dataset.
        dataset_dir: The root directory of the basil leaf dataset.
        subset: What to load (train, val, minival, valminusminival)
        """

        # Add classes
        self.add_class("leafs", 1, "healthy")
        self.add_class("leafs", 2, "withered")
        self.add_class("leafs", 3, "new_category")  # Add the new category here

        # Train or validation dataset?
        assert subset in ["train", "val"]
        dataset_dir = os.path.join(dataset_dir, subset)

        # Load the rest of the code as is
        ...

    def load_mask(self, image_id):
        ...
        for i, p in enumerate(info["polygons"]):
            ...
            if p['State'] == 'healthy':
                classes[i] = 1
            elif p['State'] == 'withered':
                classes[i] = 2
            else:
                classes[i] = 3  # Assign class ID for the new category

        # Return mask, and array of class IDs of each instance.
        return mask.astype(bool), classes

Mit diesen Änderungen wird die neue Kategorie in der Datei /samples/leafs_collage/leafs_collage.py eingebunden.

Um die KI weiter zu trainieren, befolgt die folgenden Schritte:

1. Passt die Einstellungen für das Training in der Datei leafs_collage.py ab Zeile 119 an, zum Beispiel Lernrate, Momentum und Gewichtsdekay:

python
# Learning rate and momentum
LEARNING_RATE = 0.001
LEARNING_MOMENTUM = 0.5

# Weight decay regularization
WEIGHT_DECAY = 0.01

In Zeile 343 der leafs_collage.py könnt ihr steuern, welche Schichten des Modells während des Trainings aktualisiert werden sollen. Die layers-Parameteroptionen sind:

• 'heads': Trainiert nur die Schichten in der Netzwerk-Head (z.B. die Klassifikations- und Maskenschichten), während die restlichen Schichten eingefroren bleiben.
• '3+': Trainiert alle Schichten ab der dritten Schicht und höher (einschließlich der Head-Schichten).
• '4+': Trainiert alle Schichten ab der vierten Schicht und höher (einschließlich der Head-Schichten).
• '5+': Trainiert alle Schichten ab der fünften Schicht und höher (einschließlich der Head-Schichten).

Der Code sieht dann so aus:

python
model.train(dataset_train, dataset_val,
            learning_rate=config.LEARNING_RATE,
            epochs=50,
            layers='heads', # oder '3+', '4+' oder '5+'
            augmentation=augmentation)

Ändert den Wert des layers-Parameters entsprechend euren Anforderungen. Das Training der oberen Schichten ('heads') ist in der Regel schneller und kann bei vortrainierten Modellen gute Ergebnisse liefern. Wenn ihr jedoch die Leistung des Modells weiter verbessern möchtet, könntet ihr versuchen, tiefere Schichten des Netzwerks zu trainieren, indem ihr den layers-Parameter auf '3+', '4+' oder '5+' setzt. Beachtet, dass das Training von tieferen Schichten in der Regel mehr Rechenleistung und Zeit benötigt.

1. Stellet sicher, dass ihr alle erforderlichen Bibliotheken und Abhängigkeiten installiert habt, einschließlich CUDA und NVIDIA-Bibliotheken für lokale GPU-Unterstützung. Alternativ könnt ihr Kaggle Notebooks verwenden, um die Berechnungen in der Cloud durchzuführen.
2. Wenn ihr Kaggle Notebooks verwenden möchtet, ladet den entsprechenden Datensatz in euer Kaggle Notebook hoch.
3. Führt das Training aus, indem ihr den folgenden Befehl anpasst und ausführt. Beachtet, dass ihr den Pfad für den --dataset-Parameter entsprechend dem tatsächlichen Speicherort eures Datensatzes ändern müsst. Mit dem --weights-Parameter könnt ihr wählen, ob ihr ein neues Modell auf Basis des COCO-Modells oder ein vortrainiertes Modell weiter trainieren möchten.
4. Die vortrainierten Modelle findet ihr im Release-Teil des Github-Repositories. Diese können direkt im Notebook runtergeladen werden.

bash
!python3 /kaggle/working/mask-rcnn/samples/leafs_collage/leafs_collage.py train --dataset=/kaggle/input/twoclassleafs/twoClassesIX/twoClassesIX/ --weights=coco --logs=/kaggle/working/logs/

Nachdem ihr die oben genannten Schritte ausgeführt habt, sollte euer Modell mit den neuen Daten und Einstellungen trainiert werden. Überwacht den Trainingsfortschritt und passt gegebenenfalls die Hyperparameter an, um die bestmögliche Leistung zu erzielen.

Als Trainingsstrategie hat sich folgendes Vorgehen bewährt:

• Trainiert mit einem Blattkollagen-Datensatz und einer Lernrate von 0.0001 und einem Momentum von 0,9 sowie einem Weight Decay von 0.0001 für 20-30 Epochen
• Wählt das Modell mit dem niedrigsten Loss aus zum weiter trainieren
• Trainiert das Modell mit einer reduzierten Lernrate weiter für 20 -30 Epochen und wählt das beste Modell aus
• Wiederholt den letzten Schritt bis sich der Loss nicht mehr weiter reduziert
• Feintuning: Trainiert mit einer Lernrate von 0.000001 auf dem Datensatz mit den echten segmentierten Pflanzendaten um die KI auf echte Pflanzen und nicht auf Kollagen feinzutunen.

Um das Testset zu erweitern und die Evaluierung des Modells mit Beispielen aus den neuen Daten durchzuführen, solltet ihr die folgenden Schritte ausführen:

1. Teilt die neuen Daten in Trainings- und Testsets auf. Eine typische Aufteilung ist 80% für das Training und 20% für das Testen. Ihr können dies manuell tun oder Sklearn's train_test_split verwenden, um eine zufällige Aufteilung durchzuführen.
2. Fügt die neuen Testdaten zu eurem bestehenden Testset hinzu. Stellt sicher, dass ihr alle Bilder und zugehörigen Annotationen in das richtige Verzeichnis kopiert.
3. Aktualisiert die JSON-Datei (via_region_data.json) im Testset-Verzeichnis, um die Annotationen für die neuen Testbilder einzuschließen.

Um die KI in der GUI zu evaluieren und die Testset-Performance zu berechnen, geht wie folgt vor:

1. Öffnet die grafische Benutzeroberfläche (GUI) für euer Mask-RCNN-Projekt.
2. Navigiert zum Bereich "Testset Performance" in der GUI.
3. Gebt den Pfad zum Testset-Verzeichnis ein, das die Bilder und die korrekte via_region_data.json-Datei enthält.
4. Stellt sicher, dass das trainierte Modell geladen ist. Wenn das Modell noch nicht geladen ist, ladet es, indem ihr den Pfad zum Modell unter "AI Weights" angebt.
5. Klickt auf die Schaltfläche "Test AI". Dadurch wird die Evaluierung gestartet und für jedes Bild im Testset mAP, Recall, Precision und Overlap berechnet.
6. Nachdem die Berechnungen abgeschlossen sind, wird der Durchschnitt über alle Testbilder angezeigt. Ihr könnt diese Ergebnisse verwenden, um die Leistung Ihres Modells zu beurteilen und bei Bedarf weitere Optimierungen oder Anpassungen vorzunehmen.

Um den Telegram-Bot zu implementieren und die neue Kategorie einzubinden, führt die folgenden Schritte aus:

• Klont das Repository, das den Telegram-Bot und den zugehörigen Docker-Container enthält:

bash
git clone [URL_des_Repositories]

• Kopiert die neueste Version von mask-rcnn und die aktuellen Gewichte in den entsprechenden Ordner des geklonten Repository.

Aktualisiert die Datei AIInference.py:

• Fügt die neue Kategorie in Zeile 213 hinzu:

python
buf  = visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'], 
                        ['healthy', 'withered', 'new_category'], r['scores'], fig=fig,ax=ax,
                        title="Predictions")

• Fügt die neue Kategorie ab Zeile 260 hinzu:

python
img  = display_instances(image, r['rois'], r['masks'], r['class_ids'], 
                    ['BG', 'healthy', 'withered', 'new_category'], r['scores'], fig=fig,ax=ax,
                    title="Predictions")
leaf_count = np.count_nonzero(r['class_ids'] == 1)
withered_count = np.count_nonzero(r['class_ids'] == 2)
new_category_count = np.count_nonzero(r['class_ids'] == 3)
plt.close(fig)
plt.clf()
return img, leaf_count, withered_count, new_category_count

Aktualisiert die Datei bot.py, um die neue Klasse einzubeziehen:

python
[result, l, w, n] = easy_but_slow_inference(ROOT_DIR, os.path.join(ROOT_DIR, 'mask_rcnn_leafscollage_v248.h5'), f)

response = 'I processed that and I found %s healthy, %s withered, and %s new_category leaves making it a total of %s leaves' % (l, w, n, l + w + n)

• Startet den Docker-Container auf eurem PC oder Server und stellt sicher, dass er ordnungsgemäß funktioniert.
• Nun könnt ihr dem Telegram-Bot Bilder von Basilikumblättern senden, und der Bot wird im Hintergrund eine Inferenz ausführen. Anschließend erhaltet ihr eine Nachricht mit einem Overlay und der Anzahl der erkannten Blätter für jede Kategorie.

Durch diese Änderungen sollte der Telegram-Bot in der Lage sein, die neue Kategorie in den Ergebnissen zu berücksichtigen und die Anzahl der erkannten Blätter für jede Kategorie zurückzugeben.