GeoAI: Vortrainierte Modelle mit der ArcGIS API for Python nachtrainieren

In diesem Blogartikel erhalten Sie eine Schritt-für-Schritt-Anleitung, wie Sie vortrainierte Modelle -ob aus dem Living Atlas oder selbst trainierte- mit Hilfe von Jupyter und der ArcGIS API for Python anpassen und nachtrainieren können.

Das Ziel dabei ist, dass die Modelle genauer auf den eigenen Datensätzen performen, auf welchen sie ursprünglich nicht trainiert wurden. Wenn Sie sich noch nicht mit dem Thema Deep Learning beschäftigt haben, sind folgende Artikel als Einstieg empfehlenswert: Detecting Solar Panels in Basel, Video: Geospatial Deep Learning mit ArcGIS

Es gibt drei hauptsächliche Workflows im Umgang mit Deep Learning in ArcGIS:

1. Anwenden eines von Esri vortrainierten Modells auf eigene Daten (Inferencing)
2. Nachtrainieren und Fine-Tuning eines bestehenden Modells
3. Ein neues Modell von Scratch trainieren

Wann man ein Modell weiter trainieren sollte

Deep Learning Modelle sind immer abhängig von den Daten, auf denen sie trainiert worden sind. Von einem Landklassifikationsmodell, welches auf Landsat Daten mit einer Auflösung von 30x30m trainiert wurde, kann nicht erwartet werden, dass es auf 5x5cm hoch aufgelösten Daten aus Basel funktioniert. Die Auflösung spielt also beispielsweise eine entscheidende Rolle. Aber auch andere optische Eigenschaften wie Beleuchtung, Einfallswinkel des Lichts, Kontrast, atmosphärische Störungen oder einfach optische Merkmale, wie lokale Bauweisen, beeinflussen die Performance des Modells. Trainieren Sie ein Modell zur Erkennung von Häusern auf Trainingsdaten aus Spanien, wird es in Deutschland aufgrund unterschiedlicher Baumerkmale nicht so genaue Ergebnisse liefern, wie auf Bilddaten aus Spanien, auf denen es trainiert wurde.

Sollte das Modell jedoch in der Lage sein, einen Teil der Objekte bereits zu erkennen, auch wenn die Ergebnisse noch nicht zufriedenstellend sind, kann es sich lohnen, das Modell nochmal weiter anzupassen oder ein ‚Feintuning’ zu machen.

Unten sehen Sie eine Karte aus Basel. Hier wurde bereits ein U-Net zur Erkennung der Solaranlagen trainiert. Inzwischen wurde von den Kollegen aus den USA ein MaskRCNN Modell zur Erkennung von Solaranlagen auf Daten der USA trainiert. Bei der Anwendung des Modells auf die vorliegenden Daten aus Basel fiel jedoch auf, dass das Modell nicht die gewünschte Ergebnisqualität liefert. Unter den Detektionen waren viele False Positives, also Merkmale die fälschlicherweise als Solaranlage erkannt wurden. Und einige Solaranlagen wurden nur teilweise oder auch überhaupt nicht erkannt. Hier kann weiteres Training helfen, die Performance des Modells zu verbessern.

Voraussetzungen fürs Training

Bevor das Training losgehen kann, sollten diese erforderlichen Voraussetzungen erfüllt sein:

Grafikkarte

Stellen Sie sicher, dass Ihr Computer auf eine Grafikkarte zurückgreifen kann, da diese das Training beschleunigt. Das Minimum, das Sie für die Feinabstimmung eines Deep-Learning-Modells benötigen, ist eine NVIDIA RTX oder NVIDIA Quadro mit 8 GB RAM oder etwas ähnliches. Auf Grundlage dessen können Sie ein Modell zum Test in einem kleinen Maßstab trainieren. Wenn Sie jedoch einen größeren Datensatz prozessieren, sollten Sie nach einer leistungsstärkeren GPU suchen, z. B. einer NVIDIA V100-GPU mit mindestens 16 GB RAM. Weitere Informationen zu GPU-betriebenen Produktionsumgebungen finden Sie unter NVIDIA Data Center GPUs.

CUDA 

Das CUDA-Toolkit ist eine weitere wesentliche Komponente für das Training Ihres Deep-Learning-Modells. CUDA® ist eine Parallel-Computing-Plattform und ein Programmiermodell, das von NVIDIA für allgemeines Computing auf GPUs entwickelt wurde. Mit CUDA können Entwickler Rechenanwendungen mit der Leistung von GPUs beschleunigen. Um CUDA zu installieren, besuchen Sie die CUDA Toolkit-Downloadseite.

ArcGIS Pro

Um das Modell innerhalb ArcGIS Pro auf eigene Daten anwenden zu können, werden ArcGIS Pro und die ArcGIS Image Analyst Lizenz benötigt.

Deep Learning Frameworks

Abschließend müssen die Deep Learning Frameworks für Ihre Python-Umgebung installiert sein. Diese werden direkt in die Umgebung von ArcGIS Pro installiert und können hier heruntergeladen werden. Beachten Sie dabei, dass jede Version von ArcGIS Pro unterschiedliche Deep Learning Frameworks benötigt. Auch wenn Sie ArcGIS Pro upgraden, achten Sie darauf, die neueste Version der Deep Learning Packages zu installieren.

Verstehen Sie das vortrainierte Modell

Erfüllen Sie die oben genannten Voraussetzungen, sind Sie jetzt im Stande ein ArcGIS-Deep-Learning-Modell, gespeichert als Deep Learning Package (dlpk), durch weiteres Training zu optimieren. Für den Beispielworkflow verwenden wir das dlpk Solar Panel Detection – USA, die gleiche Methodik kann jedoch auf jedes andere dlpk angewendet werden.

Die Eingangsparameter

Um einem Modell neue Trainingsdaten hinzuzufügen, müssen Sie verstehen, wie und womit das ursprüngliche Modell trainiert wurde. Meistens sind diese Informationen in den Metadaten oder der Beschreibung des dlpk enthalten. Wenn Sie die Informationen in der Modellbeschreibung auf ArcGIS Online nicht finden können oder weitere Informationen wünschen, führen Sie die folgenden Schritte aus, um auf die vollständigen dlpk-Metadaten zuzugreifen:

1. Suchen Sie das heruntergeladene Deep-Learning-Paket (das mit der Erweiterung .dlpk endet) in den Dateien auf Ihrem Computer.
2. Erstellen Sie eine Kopie dieser Datei. Dies ist wichtig, da Sie die ursprüngliche .dlpk-Datei für die Feinabstimmung verwenden.
3. Wenn Sie Dateierweiterungen im Datei-Explorer nicht sehen können, gehen Sie wie folgt vor:
4. Klicken Sie im Menü des Datei-Explorers auf Ansicht.
5. Klicken Sie unter dem Abschnitt Anzeigen/Ausblenden auf Dateinamenerweiterungen.
6. Klicken Sie mit der rechten Maustaste auf die kopierte .dlpk-Datei und klicken Sie auf Alle extrahieren…, um den Inhalt am gewünschten Ort zu speichern.
7. Klicken Sie am extrahierten Speicherort mit der rechten Maustaste auf Ihre nun entpackte .emd-Datei und öffnen Sie sie mit einem Notepad-Editor Ihrer Wahl.
8. In der .emd-Datei finden Sie die folgenden Informationen, die die Eingabeparameter für unseren Fine-Tuning-Workflow enthalten (siehe Screenshot unten für den Inhalt der .emd-Datei des Modells „Solar Panel Detection – USA“):

• ImageHeight & ImageWidth – Diese werden in die Kachelgröße übersetzt. Im dlpk, welches wir für dieses Beispiel verwenden, ist der Wert 400.
• ModelName – Dies bestimmt das Metadatenformat der Trainingsdaten, die Sie exportieren; in diesem Beispiel MaskRCNN.
• ExtractBands – Diese Variable zeigt die Anzahl der Bänder, mit denen das Modell trainiert wurde; hier wurden 3 Bänder (RGB) verwendet.
• Classes – Dies definiert die Anzahl der Klassen, die das Modell extrahiert, zusammen mit ihrem Namen und Wert. In diesem Beispiel gibt es nur eine Klasse mit dem Wert 3, die den Solaranlagen entspricht. Wenn wir uns ein Landbedeckungsklassifizierungsmodell ansehen würden, würden wir eine Klasse für jeden Landbedeckungstyp sehen. In diesem Fall verwenden wir beim Erstellen von Trainingsdaten den Wert und den Namen „3“, um mit den vorhandenen Trainingsdaten konsistent zu sein.
• Cell Size – Auflösung der Trainingsdaten. Diese Informationen finden Sie auch in der Beschreibung des Modells im ArcGIS Living Atlas. Für das verwendete DLPK sehen wir unter Cell Size, dass die Auflösung der Bilder zwischen 5-30 cm liegt.
• Stride Size – Dies definiert die Überlappung zwischen exportierten Trainingsdaten-Bildchips. Wenn Sie es mit begrenzten Trainingsdaten zu tun haben, ist es durchaus sinnvoll, mehr Chips zu erstellen. Für unser Beispiel kann jedoch mit genügend digitalisierten Trainingsdaten eine Schrittweite von 0 verwendet werden. Dadurch wird die Zeit für die Feinabstimmung erheblich verkürzt, da der von Ihren Trainingsdaten belegte Speicherplatz minimiert wird.

{
    "ModelParameters": {
        "pointrend": false,
        "backbone": "resnet50",
        "backend": "pytorch"
    },
    "Framework": "arcgis.learn.models._inferencing",
    "ModelConfiguration": "_maskrcnn_inferencing",
    "InferenceFunction": "ArcGISInstanceDetector.py",
    "ModelType": "InstanceDetection",
    "MaskRCNNkwargs": {},
    "ExtractBands": [
        0,
        1,
        2
    ],
    "SupportsVariableTileSize": true,
    "Classes": [
        {
            "Value": 3,
            "Name": "3",
            "Color": [
                36,
                94,
                13
            ]
        }
    ],
    "MinCellSize": {
        "x": 0.05,
        "y": 0.05,
        "spatialReference": {
            "wkid": 102100,
            "latestWkid": 3857
        }
    },
    "MaxCellSize": {
        "x": 0.3,
        "y": 0.3,
        "spatialReference": {
            "wkid": 102100,
            "latestWkid": 3857
        }
    },
    "ArcGISLearnVersion": "1.8.5",
    "monitored_valid_loss": 0.3574305772781372,
    "ModelFile": "SolarPanelDetection_USA.pth",
    "ImageHeight": 400,
    "ImageWidth": 400,
    "ImageSpaceUsed": "MAP_SPACE",
    "LearningRate": "slice('7.5858e-06', '7.5858e-05', None)",
    "ModelName": "MaskRCNN",
    "backend": "pytorch",
    "average_precision_score": {
        "3": 0.7649434445305026
    },
    "resize_to": 400,
    "IsMultispectral": false
}

Nachdem wir nun die Parameter für unsere Feinabstimmung bestimmt haben, können wir die Trainingsdaten für Deep Learning erstellen und exportieren.

Trainingsdaten erstellen

In einigen Fällen kann es sein, dass Sie bereits über Daten verfügen, welche Sie als Eingangspolygone zum Training nutzen können, z. B. einen vorhandenen Gebäudegrundriss-Polygon-Layer. Fahren Sie in diesem Fall mit dem nächsten Abschnitt zum Exportieren von Trainingsdaten fort. Wenn Sie keine Trainingsdaten haben und diese aus Ihren Bildern erstellen müssen, verwenden wir das Tool Objekte für Deep Learning beschriften. Mit diesem Tool können wir unsere Trainingsbeispiele in einem Feature-Service speichern. Je mehr Trainingsbeispiele wir erstellen, desto stabiler und genauer wird das Modell.

1. Wählen Sie Ihre Bilddaten im Bereich Inhalt aus, gehen Sie zur Registerkarte Bilddaten im oberen Menüband und klicken Sie auf Klassifizierungswerkzeuge > Objekte für Deep Learning beschriften.
2. Klicken Sie auf das Rechteck-Werkzeug und zeichnen Sie eine Form um ein Objekt in Ihrem Bild.
3. Wenn Sie das Rechteck vervollständigen, werden Sie aufgefordert, eine Option für „Klasse definieren“ auszuwählen.
4. Belassen Sie die Einstellung „Klassenoptionen“ auf „Neue Klasse hinzufügen“.
5. Ändern Sie das Feld Name auf den gewünschten Namen der Klasse und belassen Sie das Feld Wert auf 1 (wenn Ihre Daten wie in unserem Beispiel den Wert 3 haben, ändern Sie das Feld auf 3). Ändern Sie die Farbe auf etwas, das Sie von den Hintergrundbildern unterscheiden können.
6. Wir verwenden Namens- und Wertfelder, die mit dem übereinstimmen, was wir über die ursprüngliche Klasse in der oben heruntergeladenen .dlpk-Datei gefunden haben.

4. Jetzt sehen Sie Ihr beschriftetes Objekt im unteren Bereich des Tools. Wenn Sie ein einzelnes Objekt aus diesem Abschnitt auswählen, wird es auf der Karte ausgewählt und Sie können sie mit dem roten x löschen.
5. Labeln Sie mehr Trainingsdaten und speichern Sie diese im Menü Beschriftete Objekte. Versuchen Sie, Daten von verschiedenen Stellen rund um das Bild zu sammeln, um Unterschiede in den Bedingungen an verschiedenen Stellen innerhalb des Anwendungsgebietes zu erfassen.
6. Wenn Sie fertig sind, klicken Sie auf Trainingsdaten exportieren (neben Beschriftete Objekte in der unteren Hälfte des Tools). Achten Sie erneut darauf, dass der Classvalue dem der vorgegebenen Klasse in der .emd Datei entspricht. Es gibt auch ein eigenständiges Geoverarbeitungswerkzeug namens Trainingsdaten für Deep Learning exportieren. Beide übernehmen die gleichen Parameter – folgen Sie den Anweisungen im nächsten Abschnitt, um Ihre Trainingsdaten zu exportieren.

Bereiten Sie die Trainingsdaten vor

Um die Trainingsdaten zu exportieren, verwenden wir das Tool Trainingsdaten für Deep Learning exportieren (Image Analyst). Das Tool konvertiert beschriftete Vektor- oder Rasterdaten in Deep-Learning-Trainingsdatensätze. Die Ausgabe ist ein Ordner mit Bildschnipseln und ein Ordner mit Metadaten-Dateien im angegebenen Format. Wir werden als Format MaskRCNN auswählen.

Anschließend werden die Trainingsdaten exportiert, um das Modell „Solar Panel Detection – USA“ zu optimieren:

• Bilder – Die Bilder werden zur Generierung von Bildchips verwendet. Bildchips sind kleine zugeschnittene Abschnitte der Eingabebilder, die mit den zugehörigen Metadaten den nächsten Schritt für die Eingabe des Trainings bilden.

• Trainingsdaten – Die Trainingsdaten sind eine Feature-Klasse, die die Umrisse der Solaranlagen abbilden. Für jede Anlage gibt es ein Polygon, da das Modell aus den ausgelassenen Bereichen auch lernt, was keine Solaranlage ist. Jedes Polygon hat ein Attribut „Klasse“ (bzw. „Classvalue“) mit einem Wert, um zu kennzeichnen, dass es sich bei allen um den gleichen Merkmalstyp handelt. Ein Modell kann auch mit mehreren Klassen trainiert werden, um beispielsweise Landbedeckungen zu unterscheiden.

Jetzt können wir das Tool „Trainingsdaten für Deep Learning exportieren“ ausführen.

Modell nachtrainieren

In diesem Abschnitt werden wir die exportieren Trainingsdaten nutzen, um das Modell in Jupyter Notebook weiter zu trainieren. Dabei kommt die ArcGIS API for Python zum Einsatz.

Für die Bestimmung der Parameter zum Training des Modells, dient die Referenz der API als Erklärungshilfe.

Dafür importieren wir als erstes die für das Training, mit dem Deep Learning Installer installierten, Bibliotheken. Da es sich bei dem Modell wie schon erwähnt um ein MaskRCNN handelt, importieren wir die entsprechende Klasse und die prepare_data Funktion, um unsere Daten für das Training vorzubereiten.

Als nächstes bestimmen wir zwei Variablen als Pfade:

1. Den Pfad zu dem Modell, das wir nachtrainieren möchten
2. Den Pfad zu unseren Trainingsdaten

In diesem Fall trainieren wir mit einer batch_size von 8 und ohne transforms. Der Parameter transforms beschreibt in der prepare_data Funktion die Data Augmentation. Da das learn Modul der ArcGIS API for Python auf den bekannten Deep Learning Frameworks wie Tensorflow, Keras, Pytorch und fastai beruht, können Data Augmentation Parameter über die fastai-Bibliothek übergeben werden. Data Augmentation erhöht die Anzahl an Trainingsdaten und bringt gleichzeitig Variation in die Bilder und macht das Modell stabiler, indem die Bilder beispielsweise zufällig gespiegelt, gedreht oder zugeschnitten werden. Die transforms werden hierbei als Tuple übergeben.

Eine ausführliche Erklärung für mögliche Transformationen können in der fastai Referenz nachgelesen werden.

Das Objekt MaskRCNN wird als Variable initialisiert, wobei als Daten die aus der prepare_data-Funktion vorbereiteten Daten, sowie das Vortrainierte-Modell übergeben werden.

Als nächstes nutzen wir die Funktion lr_find() um die geeignete Learning Rate für das Training zu bestimmen.

Bevor wir mit dem Training starten, können wir die aktuelle Performance des Modells mit model.show_results() überprüfen. Auf der linken Seite der vier Bilder wird die Ground Truth angezeigt, also das Label der Solaranlage und auf der rechten Seite die Voraussage des Modells. Auf beiden Bildern sind vor dem Training Fehldetektionen zu erkennen.

Anschließend starten wir das Training mit model.fit(). Hier übergeben wir die Anzahl der zu trainierenden Epochen, sowie unsere bestimmte Learning Rate. Außerdem können wir mit dem Parameter early_stopping bestimmen, ob das Training automatisch stoppen soll, wenn das Modell sich nicht weiter verbessert.

Sollte dabei ein CUDA Out-of-Memory Error auftreten, muss die Batch Size in der prepare_data Funktion verringert werden, da die GPU sonst nicht mit der Größe der Batches während des Trainings umgehen kann.

Die Performance und Auslastung der Grafikkarte können Sie über den nvidia-smi Befehl abfragen.

Nach Abschluss des Trainings können wir erneut die Performance des Modells checken. Dabei fällt auf, dass das Modell keine Fehldetektionen mehr aufweist.

Anschließend speichern wir das Modell in einem von uns bestimmten Pfad und können es nun in ArcGIS Pro anwenden.

Anwendung des nachtrainierten Modells

Jetzt sind wir bereit, unser Modell für die Inferenz auf unsere eigenen Daten anzuwenden. Dazu verwenden wir das Geoverarbeitungswerkzeug Objekte mit Deep Learning erkennen (Image Analyst).

Für die Anwendung nutzen wir unser Raster aus Basel als Eingangsdaten. Als Output generieren wir durch die Anwendung unseres Modells Polygone, welche die Solaranlagen in Basel markieren.

Beachten Sie, dass die Eingabeparameterwerte für die Inferenz für verschiedene Projekte je nach Hardwarespezifikation, GPU Typ, Bildauflösung und Größe der Features, die erkannt werden sollen, variieren. Die Bestimmung der optimalen Parameter für Ihren Inferenz-Workflow kann einige Versuche erfordern und ist ein iterativer Prozess. Um verschiedene Einstellungen zu testen, gehen Sie zur Registerkarte Umgebungen des Tools und legen Sie den Verarbeitungsumfang auf einen kleinen Bereich fest. Damit können Sie die Performance mit Ihren festgelegten Einstellungen auf einen kleinen Ausschnitt des Bildes testen. Die folgenden Parameter wurden für das Modell zur Erkennung von Solaranlagen verwendet.

Eingaberaster: Bilder mit einer Auflösung zwischen 5 und 40 cm.

Ausgabe der erkannten Objekte: Ein beliebiges File-Geodatabase-Verzeichnis Ihrer Wahl auf Ihrem Computer.

Modelldefinition: Neue .dlpk-Datei, die durch unser Training generiert wurde.

Argumente:

• padding: 64

• batch_size: 16. Hinweis: Wenn Sie dieselbe Maschine für Training und Inferenz verwenden, können Sie eine höhere Batchgröße für die Inferenz als die für das Training verwendete ausprobieren.

• threshold: 0,9 (entspricht 90 Prozent, das heißt, wenn das Modell zu 90 Prozent sicher ist, dass das extrahierte Feature eine Solaranlage ist, wird es in die Ausgabe aufgenommen. Verwenden Sie einen niedrigeren Wert, um ein vollständigeres Bild der erkannten Features zu erhalten. Sie können Features unterhalb eines bestimmten Threshold später herausfiltern.)

• return_bboxes: False (geben Sie True ein, wenn Sie BoundingBox-Polygone um die erkannten Features zurückgeben möchten).

• tile_size: 400 (Dies ist die gleiche Kachelgröße, die beim Exportieren der Trainingsdaten verwendet wurde. Wenn Ihre Bilddaten Features enthalten, die in der Fläche variieren, kann es sich lohnen, mit verschiedenen Eingaben für tile_size zu experimentieren. Multiplizieren oder dividieren Sie die Kachelgröße der Trainingsdaten mit 2 und überprüfen Sie die Ergebnisse visuell.)

Non-Maximum-Suppression: Nicht aktiviert

Klicken Sie auf die Registerkarte Umgebungen:

Zellengröße: 0.05 (Entspricht einer Bildauflösung von 5cm)

Prozessortyp: GPU

GPU-ID: 0 (in der Regel 0, die korrekte GPU-ID kann über nvidia-smi überprüft werden)

Belassen Sie alle anderen Parameter auf der Standardeinstellung.

Wenn Sie fertig sind, klicken Sie auf Ausführen.

Als Ergebnis erhalten wir Polygone, welche sich gut mit den erkannten Objekten des vorangegangenen Modells vergleichen lassen.

In diesem Blogbeitrag haben wir diskutiert, wann Sie die Feinabstimmung eines vorhandenen Deep-Learning-Modells im Vergleich zur Verwendung der Out-of-the-Box-Version oder der Erstellung Ihres eigenen Modells, neu erwägen sollten. Für Fälle, in denen die Feinabstimmung das beste Ergebnis liefert, haben wir die technischen Voraussetzungen, Schritte und Eingabeparameter für den Workflow behandelt. Laden Sie ein anderes vortrainiertes Modell aus ArcGIS Living Atlas herunter und erstellen Sie Ihre eigenen Trainingsdaten, um sie an Ihre Bilddaten und Ihren Anwendungsfall anzupassen.

Rot: Vor dem Nachtrainieren, Grün: Nach dem Nachtrainieren