Objekterkennung ist von zentraler Bedeutung künstliche Intelligenzund dient als Rückgrat für zahlreiche hochmoderne Anwendungen. Von autonomen Fahrzeugen und Überwachungssystemen bis hin zu medizinischer Bildgebung und erweiterter Realität – die Fähigkeit, Objekte in Bildern und Movies zu identifizieren und zu lokalisieren, verändert Industrien weltweit. Die Objekterkennungs-API von TensorFlow, ein leistungsstarkes und vielseitiges Software, vereinfacht die Erstellung robuster Objekterkennungsmodelle. Durch die Nutzung dieser API können Entwickler benutzerdefinierte Modelle trainieren, die auf spezifische Anforderungen zugeschnitten sind, wodurch die Entwicklungszeit und -komplexität erheblich reduziert wird.

In diesem Leitfaden untersuchen wir Schritt für Schritt den Prozess des Trainierens eines Objekterkennungsmodells mit TensorFlow und konzentrieren uns dabei auf die Integration von Datensätzen aus Roboflow-Universumein umfangreiches Repository mit kommentierten Datensätzen, das die KI-Entwicklung beschleunigen soll.

Lernziele

• Erfahren Sie, wie Sie es einrichten und konfigurieren TensorFlow’s Objekterkennungs-API-Umgebung für effizientes Modelltraining.
• Erfahren Sie, wie Sie mithilfe des TFRecord-Codecs Datensätze für das Coaching vorbereiten und vorverarbeiten.
• Erwerben Sie Fachwissen bei der Auswahl und Anpassung eines vorab trainierten Objekterkennungsmodells für spezifische Anforderungen.
• Erfahren Sie, wie Sie Pipeline-Konfigurationsdateien anpassen und Modellparameter optimieren, um die Leistung zu optimieren.
• Beherrschen Sie den Trainingsprozess, einschließlich der Handhabung von Kontrollpunkten und der Bewertung der Modellleistung während des Trainings.
• Erfahren Sie, wie Sie das trainierte Modell zur Inferenz und Bereitstellung in realen Anwendungen exportieren.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Schrittweise Implementierung der Objekterkennung mit TensorFlow

In diesem Abschnitt führen wir Sie Schritt für Schritt durch die Implementierung der Objekterkennung mit TensorFlow und begleiten Sie von der Einrichtung bis zur Bereitstellung.

Schritt 1: Einrichten der Umgebung

Die TensorFlow Object Detection API erfordert verschiedene Abhängigkeiten. Beginnen Sie mit dem Klonen des TensorFlow-Modellrepositorys:

# Clone the tensorflow fashions repository from GitHub
!pip uninstall Cython -y # Non permanent repair for "No module named 'object_detection'" error
!git clone --depth 1 https://github.com/tensorflow/fashions

• Cython deinstallieren: Dieser Schritt stellt sicher, dass es während des Setups zu keinen Konflikten mit der Cython-Bibliothek kommt.
• Klonen Sie das TensorFlow-Modell-Repository: Dieses Repository enthält die offiziellen Modelle von TensorFlow, einschließlich der Objekterkennungs-API.

Kopieren Sie die Setup-Dateien und ändern Sie die Datei setup.py

# Copy setup recordsdata into fashions/analysis folder
%%bash
cd fashions/analysis/
protoc object_detection/protos/*.proto --python_out=.
#cp object_detection/packages/tf2/setup.py .

# Modify setup.py file to put in the tf-models-official repository focused at TF v2.8.0
import re
with open('/content material/fashions/analysis/object_detection/packages/tf2/setup.py') as f:
    s = f.learn()

with open('/content material/fashions/analysis/setup.py', 'w') as f:
    # Set fine_tune_checkpoint path
    s = re.sub('tf-models-official>=2.5.1',
               'tf-models-official==2.8.0', s)
    f.write(s)

Warum ist das notwendig?

• Zusammenstellung der Protokollpuffer: Die Objekterkennungs-API verwendet .proto-Dateien, um Modellkonfigurationen und Datenstrukturen zu definieren. Diese müssen in Python-Code kompiliert werden, damit sie funktionieren.
• Kompatibilität der Abhängigkeitsversion: TensorFlow und seine Abhängigkeiten entwickeln sich weiter. Die Verwendung von tf-models-official>=2.5.1 kann versehentlich eine inkompatible Model für TensorFlow v2.8.0 installieren.
• Durch die explizite Einstellung von tf-models-official==2.8.0 werden mögliche Versionskonflikte vermieden und die Stabilität gewährleistet.

Abhängigkeitsbibliotheken installieren

TensorFlow-Modelle basieren häufig auf bestimmten Bibliotheksversionen. Durch die Korrektur der TensorFlow-Model wird eine reibungslose Integration gewährleistet.

# Set up the Object Detection API 

# Have to do a brief repair with PyYAML as a result of Colab is not capable of set up PyYAML v5.4.1
!pip set up pyyaml==5.3
!pip set up /content material/fashions/analysis/

# Have to downgrade to TF v2.8.0 as a result of Colab compatibility bug with TF v2.10 (as of 10/03/22)
!pip set up tensorflow==2.8.0

# Set up CUDA model 11.0 (to keep up compatibility with TF v2.8.0)
!pip set up tensorflow_io==0.23.1
!wget https://developer.obtain.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
!mv cuda-ubuntu1804.pin /and many others/apt/preferences.d/cuda-repository-pin-600
!wget http://developer.obtain.nvidia.com/compute/cuda/11.0.2/local_installers/cuda-repo-ubuntu1804-11-0-local_11.0.2-450.51.05-1_amd64.deb
!dpkg -i cuda-repo-ubuntu1804-11-0-local_11.0.2-450.51.05-1_amd64.deb
!apt-key add /var/cuda-repo-ubuntu1804-11-0-local/7fa2af80.pub
!apt-get replace && sudo apt-get set up cuda-toolkit-11-0
!export LD_LIBRARY_PATH=/usr/native/cuda-11.0/lib64:$LD_LIBRARY_PATH

Während Sie diesen Block ausführen, müssen Sie die Sitzungen erneut starten und diesen Codeblock erneut ausführen, um alle Abhängigkeiten erfolgreich zu installieren. Dadurch werden alle Abhängigkeiten erfolgreich installiert.

Installieren einer geeigneten Model der Protobuf-Bibliothek zur Lösung von Abhängigkeitsproblemen

!pip set up protobuf==3.20.1

Schritt 2: Umgebung und Installationen überprüfen

Um zu bestätigen, dass die Set up funktioniert, führen Sie den folgenden Check durch:

# Run Mannequin Bulider Check file, simply to confirm every little thing's working correctly
!python /content material/fashions/analysis/object_detection/builders/model_builder_tf2_test.py

Wenn keine Fehler angezeigt werden, ist Ihre Einrichtung abgeschlossen. Nun haben wir die Einrichtung erfolgreich abgeschlossen.

Schritt 3: Bereiten Sie die Trainingsdaten vor

Für dieses Tutorial verwenden wir die „Personenerkennung“ Datensatz von Roboflow-Universum. Befolgen Sie diese Schritte, um es vorzubereiten:

Besuchen Sie die Datensatzseite:

Verzweigen Sie den Datensatz in Ihren Arbeitsbereich, um ihn für die Anpassung zugänglich zu machen.

Generieren Sie eine Model des Datensatzes, um seine Vorverarbeitungskonfigurationen wie Erweiterung und Größenänderung abzuschließen.

Laden Sie es jetzt im TFRecord-Format herunter, einem Binärformat, das für TensorFlow-Workflows optimiert ist. TFRecord speichert Daten effizient und ermöglicht TensorFlow das Lesen großer Datensätze während des Trainings mit minimalem Overhead.

Platzieren Sie nach dem Herunterladen die Datensatzdateien in Ihrem Google Drive, mounten Sie Ihren Code auf Ihrem Laufwerk und laden Sie diese Dateien in den Code, um ihn zu verwenden.

from google.colab import drive
drive.mount('/content material/gdrive')


train_record_fname="/content material/gdrive/MyDrive/photographs/prepare/prepare.tfrecord"
val_record_fname="/content material/gdrive/MyDrive/photographs/take a look at/take a look at.tfrecord"
label_map_pbtxt_fname="/content material/gdrive/MyDrive/photographs/label_map.pbtxt"

Schritt 4: Richten Sie die Trainingskonfiguration ein

Jetzt ist es an der Zeit, die Konfiguration für das Objekterkennungsmodell einzurichten. Für dieses Beispiel verwenden wir das Modell „efficientdet-d0“. Sie können aus anderen Modellen wie ssd-mobilenet-v2 oder ssd-mobilenet-v2-fpnlite-320 wählen, aber in diesem Leitfaden konzentrieren wir uns aufefficientdet-d0.

# Change the chosen_model variable to deploy totally different fashions obtainable within the TF2 object detection zoo
chosen_model="efficientdet-d0"

MODELS_CONFIG = {
    'ssd-mobilenet-v2': {
        'model_name': 'ssd_mobilenet_v2_320x320_coco17_tpu-8',
        'base_pipeline_file': 'ssd_mobilenet_v2_320x320_coco17_tpu-8.config',
        'pretrained_checkpoint': 'ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz',
    },
    'efficientdet-d0': {
        'model_name': 'efficientdet_d0_coco17_tpu-32',
        'base_pipeline_file': 'ssd_efficientdet_d0_512x512_coco17_tpu-8.config',
        'pretrained_checkpoint': 'efficientdet_d0_coco17_tpu-32.tar.gz',
    },
    'ssd-mobilenet-v2-fpnlite-320': {
        'model_name': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8',
        'base_pipeline_file': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.config',
        'pretrained_checkpoint': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz',
    },
}

model_name = MODELS_CONFIG(chosen_model)('model_name')
pretrained_checkpoint = MODELS_CONFIG(chosen_model)('pretrained_checkpoint')
base_pipeline_file = MODELS_CONFIG(chosen_model)('base_pipeline_file')

Anschließend laden wir die vorab trainierten Gewichte und die entsprechende Konfigurationsdatei für das gewählte Modell herunter:

# Create "mymodel" folder for holding pre-trained weights and configuration recordsdata
%mkdir /content material/fashions/mymodel/
%cd /content material/fashions/mymodel/

# Obtain pre-trained mannequin weights
import tarfile
download_tar="http://obtain.tensorflow.org/fashions/object_detection/tf2/20200711/" + pretrained_checkpoint
!wget {download_tar}
tar = tarfile.open(pretrained_checkpoint)
tar.extractall()
tar.shut()

# Obtain coaching configuration file for mannequin
download_config = 'https://uncooked.githubusercontent.com/tensorflow/fashions/grasp/analysis/object_detection/configs/tf2/' + base_pipeline_file
!wget {download_config}

Danach richten wir die Anzahl der Trainingsschritte und die Batchgröße basierend auf dem ausgewählten Modell ein:

# Set coaching parameters for the mannequin
num_steps = 4000

if chosen_model == 'efficientdet-d0':
  batch_size = 8
else:
  batch_size = 8

Sie können „num_steps“ und „batch_size“ entsprechend Ihren Anforderungen erhöhen und verringern.

Schritt 5: Ändern Sie die Pipeline-Konfigurationsdatei

Wir müssen die Datei „pipeline.config“ mit den Pfaden zu unseren Datensatz- und Modellparametern anpassen. Die Datei „pipeline.config“ enthält verschiedene Konfigurationen wie die Stapelgröße, die Anzahl der Klassen und Prüfpunkte zur Feinabstimmung. Wir nehmen diese Änderungen vor, indem wir die Vorlage lesen und die relevanten Felder ersetzen:

# Set file areas and get variety of courses for config file
pipeline_fname="/content material/fashions/mymodel/" + base_pipeline_file
fine_tune_checkpoint="/content material/fashions/mymodel/" + model_name + '/checkpoint/ckpt-0'

def get_num_classes(pbtxt_fname):
    from object_detection.utils import label_map_util
    label_map = label_map_util.load_labelmap(pbtxt_fname)
    classes = label_map_util.convert_label_map_to_categories(
        label_map, max_num_classes=90, use_display_name=True)
    category_index = label_map_util.create_category_index(classes)
    return len(category_index.keys())
num_classes = get_num_classes(label_map_pbtxt_fname)
print('Whole courses:', num_classes)

# Create customized configuration file by writing the dataset, mannequin checkpoint, and coaching parameters into the bottom pipeline file
import re

%cd /content material/fashions/mymodel
print('writing customized configuration file')

with open(pipeline_fname) as f:
    s = f.learn()
with open('pipeline_file.config', 'w') as f:

    # Set fine_tune_checkpoint path
    s = re.sub('fine_tune_checkpoint: ".*?"',
               'fine_tune_checkpoint: "{}"'.format(fine_tune_checkpoint), s)

    # Set tfrecord recordsdata for prepare and take a look at datasets
    s = re.sub(
        '(input_path: ".*?)(PATH_TO_BE_CONFIGURED/prepare)(.*?")', 'input_path: "{}"'.format(train_record_fname), s)
    s = re.sub(
        '(input_path: ".*?)(PATH_TO_BE_CONFIGURED/val)(.*?")', 'input_path: "{}"'.format(val_record_fname), s)

    # Set label_map_path
    s = re.sub(
        'label_map_path: ".*?"', 'label_map_path: "{}"'.format(label_map_pbtxt_fname), s)

    # Set batch_size
    s = re.sub('batch_size: (0-9)+',
               'batch_size: {}'.format(batch_size), s)

    # Set coaching steps, num_steps
    s = re.sub('num_steps: (0-9)+',
               'num_steps: {}'.format(num_steps), s)

    # Set variety of courses num_classes
    s = re.sub('num_classes: (0-9)+',
               'num_classes: {}'.format(num_classes), s)

    # Change fine-tune checkpoint kind from "classification" to "detection"
    s = re.sub(
        'fine_tune_checkpoint_type: "classification"', 'fine_tune_checkpoint_type: "{}"'.format('detection'), s)

    # If utilizing ssd-mobilenet-v2, scale back studying charge (as a result of it is too excessive within the default config file)
    if chosen_model == 'ssd-mobilenet-v2':
      s = re.sub('learning_rate_base: .8',
                 'learning_rate_base: .08', s)

      s = re.sub('warmup_learning_rate: 0.13333',
                 'warmup_learning_rate: .026666', s)

    # If utilizing efficientdet-d0, use fixed_shape_resizer as an alternative of keep_aspect_ratio_resizer (as a result of it is not supported by TFLite)
    if chosen_model == 'efficientdet-d0':
      s = re.sub('keep_aspect_ratio_resizer', 'fixed_shape_resizer', s)
      s = re.sub('pad_to_max_dimension: true', '', s)
      s = re.sub('min_dimension', 'peak', s)
      s = re.sub('max_dimension', 'width', s)

    f.write(s)


# (Optionally available) Show the customized configuration file's contents
!cat /content material/fashions/mymodel/pipeline_file.config

# Set the trail to the customized config file and the listing to retailer coaching checkpoints in
pipeline_file="/content material/fashions/mymodel/pipeline_file.config"
model_dir="/content material/coaching/"

Schritt 6: Trainieren Sie das Modell

Jetzt können wir das Modell mithilfe der benutzerdefinierten Pipeline-Konfigurationsdatei trainieren. Das Trainingsskript speichert Prüfpunkte, mit denen Sie die Leistung Ihres Modells bewerten können:

# Run coaching!
!python /content material/fashions/analysis/object_detection/model_main_tf2.py 
    --pipeline_config_path={pipeline_file} 
    --model_dir={model_dir} 
    --alsologtostderr 
    --num_train_steps={num_steps} 
    --sample_1_of_n_eval_examples=1

Schritt 7: Speichern Sie das trainierte Modell

Nach Abschluss des Trainings exportieren wir das trainierte Modell, damit es für Inferenzen verwendet werden kann. Wir verwenden das Skript exporter_main_v2.py, um das Modell zu exportieren:

!python /content material/fashions/analysis/object_detection/exporter_main_v2.py 
    --input_type image_tensor 
    --pipeline_config_path {pipeline_file} 
    --trained_checkpoint_dir {model_dir} 
    --output_directory /content material/exported_model

Zum Schluss komprimieren wir das exportierte Modell zum einfachen Herunterladen in eine ZIP-Datei. Anschließend können Sie die ZIP-Datei mit Ihrem trainierten Modell herunterladen:

import shutil
# Path to the exported mannequin folder
exported_model_path="/content material/exported_model"

# Path the place the zip file might be saved
zip_file_path="/content material/exported_model.zip"

# Create a zipper file of the exported mannequin folder
shutil.make_archive(zip_file_path.exchange('.zip', ''), 'zip', exported_model_path)

# Obtain the zip file utilizing Google Colab's file obtain utility
from google.colab import recordsdata
recordsdata.obtain(zip_file_path)

Sie können diese heruntergeladenen Modelldateien je nach Bedarf zum Testen an unsichtbaren Bildern oder in Ihren Anwendungen verwenden.

Darauf können Sie sich beziehen: Kollaborationsnotizbuch für detaillierten Code

Abschluss

Zusammenfassend stattet Sie dieser Leitfaden mit den Kenntnissen und Werkzeugen aus, die Sie zum Trainieren eines Objekterkennungsmodells mithilfe der Objekterkennungs-API von TensorFlow benötigen, wobei Datensätze aus Roboflow Universe für eine schnelle Anpassung genutzt werden. Indem Sie die beschriebenen Schritte befolgen, können Sie Ihre Daten effektiv vorbereiten, die Trainingspipeline konfigurieren, das richtige Modell auswählen und es an Ihre spezifischen Anforderungen anpassen. Darüber hinaus eröffnet die Möglichkeit, Ihr trainiertes Modell zu exportieren und bereitzustellen, enorme Möglichkeiten für reale Anwendungen, sei es in autonomen Fahrzeugen, medizinischen Bildgebungssystemen oder Überwachungssystemen. Mit diesem Workflow können Sie leistungsstarke, skalierbare Objekterkennungssysteme mit geringerer Komplexität und schnellerer Bereitstellung erstellen.

Wichtige Erkenntnisse

• Die TensorFlow Object Detection API bietet ein flexibles Framework zum Erstellen benutzerdefinierter Objekterkennungsmodelle mit vorab trainierten Optionen, wodurch Entwicklungszeit und Komplexität reduziert werden.
• Das TFRecord-Format ist für eine effiziente Datenverarbeitung, insbesondere bei großen Datensätzen in TensorFlow, unerlässlich und ermöglicht schnelles Coaching und minimalen Overhead.
• Pipeline-Konfigurationsdateien sind für die Feinabstimmung und Anpassung des Modells an Ihren spezifischen Datensatz und die gewünschten Leistungsmerkmale von entscheidender Bedeutung.
• Vorab trainierte Modelle wie „efficientdet-d0“ und „ssd-mobilenet-v2“ bieten solide Ausgangspunkte für das Coaching benutzerdefinierter Modelle, wobei jedes Modell je nach Anwendungsfall und Ressourcenbeschränkungen spezifische Stärken aufweist.
• Der Trainingsprozess umfasst die Verwaltung von Parametern wie Batch-Größe, Anzahl der Schritte und Modell-Checkpoints, um sicherzustellen, dass das Modell optimum lernt.
• Der Export des Modells ist unerlässlich, um das trainierte Objekterkennungsmodell in einem realen Modell zu verwenden, das gepackt wird und für die Bereitstellung bereit ist.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

TensorFlows Sequentielle API hilft dem Benutzer, Schichten übereinander zu stapeln und so einfach lineare Modelle zu erstellen, bei denen die Eingabe jeder Schicht immer die Ausgabe der vorherigen ist. Aber was passiert, wenn Ihr Modell mehrere Ein- oder Ausgaben, gemeinsam genutzte Ebenen oder nichtlineare Verbindungen verarbeiten muss? In diesen Szenarien Die funktionale API von TensorFlow ermöglicht die Erstellung fortschrittlicherer, flexiblerer und anpassbarerer Modelle und gibt dem Benutzer die Möglichkeit, die oben genannten komplexen Architekturen problemlos zu entwerfen.

Dieser Artikel erklärt:

• Was ist die funktionale API?
• So erstellen Sie ein einfaches Modell mit der Useful API

TensorFlows Funktionale API ist eine Möglichkeit, Modelle zu erstellen, bei denen Ebenen wie ein Netzwerkdiagramm verbunden und nicht nur linear gestapelt sind wie im Sequentielle API. Stellen Sie sich das Bauen mit LEGO-Steinen vor: Während die Sequential API es uns lediglich ermöglichen würde, Blöcke übereinander zu stapeln, ermöglicht uns die Useful API den Bau von Brücken, Türmen und Wegen, die verschiedene Bereiche verbinden.

Gepostet von Dustin Zelle, Software program Engineer, Google Analysis, und Arno Eigenwillig, Software program Engineer, CoreML

Objekte und ihre Beziehungen sind in der Welt um uns herum allgegenwärtig, und Beziehungen können für das Verständnis eines Objekts genauso wichtig sein wie seine eigenen Attribute, isoliert betrachtet – man denke zum Beispiel an Transportnetzwerke, Produktionsnetzwerke, Wissensgraphen oder soziale Netzwerke. Diskrete Mathematik und Informatik haben eine lange Geschichte der Formalisierung solcher Netzwerke wie Grafikenbestehend aus Knoten verbunden über Kanten auf verschiedene unregelmäßige Weise. Dennoch ermöglichen die meisten Algorithmen des maschinellen Lernens (ML) nur regelmäßige und einheitliche Beziehungen zwischen Eingabeobjekten, beispielsweise ein Pixelraster, eine Wortfolge oder überhaupt keine Beziehung.

Zeichnen Sie neuronale Netzeoder kurz GNNs, haben sich als leistungsstarke Technik herausgestellt, um sowohl die Konnektivität des Graphen zu nutzen (wie in den älteren Algorithmen). DeepWalk Und Node2Vec) und die Eingabefunktionen an den verschiedenen Knoten und Kanten. GNNs können Vorhersagen für Graphen als Ganzes treffen (Reagiert dieses Molekül auf eine bestimmte Weise?), für einzelne Knoten (Was ist das Thema dieses Dokuments, angesichts seiner Zitate?) oder für potenzielle Kanten (Wird dieses Produkt wahrscheinlich zusammen mit jenem Produkt gekauft?). Abgesehen davon, dass sie Vorhersagen über Graphen treffen, sind GNNs ein leistungsfähiges Werkzeug, um die Kluft zu typischeren Anwendungsfällen neuronaler Netzwerke zu überbrücken. Sie kodieren die diskret, relational Informationen in einem kontinuierlich so dass es auf natürliche Weise in ein anderes Deep-Studying-System integriert werden kann.

Wir freuen uns, die Veröffentlichung von bekannt zu geben TensorFlow GNN 1.0 (TF-GNN), eine produktionserprobte Bibliothek zum Aufbau von GNNs in großem Maßstab. Es unterstützt sowohl die Modellierung und das Coaching in TensorFlow als auch die Extraktion von Eingabediagrammen aus riesigen Datenspeichern. TF-GNN wurde von Grund auf für heterogene Graphen entwickelt, bei denen Objekttypen und Beziehungen durch unterschiedliche Sätze von Knoten und Kanten dargestellt werden. Objekte der realen Welt und ihre Beziehungen kommen in unterschiedlichen Typen vor, und der heterogene Fokus von TF-GNN macht es natürlich, sie darzustellen.

In TensorFlow werden solche Diagramme durch Objekte des Typs dargestellt tfgnn.GraphTensor. Dies ist ein zusammengesetzter Tensortyp (eine Sammlung von Tensoren in einer Python-Klasse), der als akzeptiert wird Bürger erster Klasse In tf.knowledge.Dataset, tf.operateusw. Es speichert sowohl die Diagrammstruktur als auch ihre an Knoten, Kanten und das Diagramm als Ganzes gebundenen Merkmale. Trainierbare Transformationen von GraphTensors können auf hoher Ebene als Layer-Objekte definiert werden Keras-APIoder direkt über die tfgnn.GraphTensor Primitive.

GNNs: Vorhersagen für ein Objekt im Kontext treffen

Schauen wir uns zur Veranschaulichung eine typische Anwendung von TF-GNN an: die Vorhersage einer Eigenschaft eines bestimmten Knotentyps in einem Diagramm, das durch Querverweise auf Tabellen einer riesigen Datenbank definiert wird. Zum Beispiel eine Zitierdatenbank für arXiv-Aufsätze im Bereich Informatik (CS) mit Eins-zu-vielen-Zitaten und Viele-zu-eins-Zitatbeziehungen, in der wir den Themenbereich jedes Aufsatzes vorhersagen möchten.

Wie die meisten neuronalen Netze wird ein GNN anhand eines Datensatzes mit vielen markierten Beispielen (~ Millionen) trainiert, aber jeder Trainingsschritt besteht nur aus einer viel kleineren Menge an Trainingsbeispielen (z. B. Hunderten). Um auf Millionen zu skalieren, wird das GNN anhand eines Stroms einigermaßen kleiner Untergraphen aus dem zugrunde liegenden Graphen trainiert. Jeder Untergraph enthält genügend Originaldaten, um das GNN-Ergebnis für den markierten Knoten in seiner Mitte zu berechnen und das Modell zu trainieren. Dieser Prozess – typischerweise als Subgraph-Sampling bezeichnet – ist äußerst folgenreich für das GNN-Coaching. Die meisten vorhandenen Instruments führen die Stichprobenerhebung stapelweise durch und erzeugen statische Teilgraphen für das Coaching. TF-GNN bietet Instruments, um dies durch dynamisches und interaktives Sampling zu verbessern.

Abgebildet ist der Prozess des Subgraph-Samplings, bei dem kleine, nachvollziehbare Subgraphen aus einem größeren Graphen abgetastet werden, um Eingabebeispiele für das GNN-Coaching zu erstellen.

TF-GNN 1.0 führt eine versatile Python-API ein, um dynamisches oder Batch-Subgraph-Sampling in allen relevanten Maßstäben zu konfigurieren: interaktiv in einem Colab-Notizbuch (wie Dieses hier), für die effiziente Stichprobennahme eines kleinen Datensatzes, der im Hauptspeicher eines einzelnen Trainingshosts gespeichert ist oder verteilt wird durch Apache Beam für riesige Datensätze, die in einem Netzwerkdateisystem gespeichert sind (bis zu Hunderten Millionen Knoten und Milliarden Kanten). Einzelheiten finden Sie in unseren Benutzerhandbüchern in Erinnerung Und strahlbasiert Probenahme bzw.

Auf denselben abgetasteten Teilgraphen besteht die Aufgabe des GNN darin, einen verborgenen (oder latenten) Zustand am Wurzelknoten zu berechnen; Der verborgene Zustand aggregiert und kodiert die relevanten Informationen der Nachbarschaft des Wurzelknotens. Ein klassischer Ansatz ist Nachrichtenübertragende neuronale Netze. In jeder Runde der Nachrichtenübermittlung empfangen Knoten Nachrichten von ihren Nachbarn entlang der eingehenden Kanten und aktualisieren ihren eigenen verborgenen Standing von ihnen. Nach N Runden spiegelt der verborgene Zustand des Wurzelknotens die aggregierten Informationen aller Knoten innerhalb N Kanten (siehe Abbildung unten für N = 2). Die Nachrichten und die neuen verborgenen Zustände werden von verborgenen Schichten des neuronalen Netzwerks berechnet. In einem heterogenen Diagramm ist es oft sinnvoll, separat trainierte verborgene Schichten für die verschiedenen Arten von Knoten und Kanten zu verwenden

Abgebildet ist ein einfaches neuronales Netzwerk zur Nachrichtenübermittlung, bei dem bei jedem Schritt der Knotenzustand von äußeren zu inneren Knoten weitergegeben wird, wo er gepoolt wird, um neue Knotenzustände zu berechnen. Sobald der Wurzelknoten erreicht ist, kann eine endgültige Vorhersage getroffen werden.

Der Trainingsaufbau wird abgeschlossen, indem eine Ausgabeschicht über dem verborgenen Zustand des GNN für die gekennzeichneten Knoten platziert und berechnet wird Verlust (um den Vorhersagefehler zu messen) und Aktualisierung der Modellgewichte durch Backpropagation, wie es bei jedem neuronalen Netzwerktraining üblich ist.

Neben dem überwachten Coaching (d. h. der Minimierung eines durch Labels definierten Verlusts) können GNNs auch unüberwacht (d. h. ohne Labels) trainiert werden. Dies ermöglicht uns die Berechnung eines kontinuierlich Vertretung (oder Einbettung) des diskret Diagrammstruktur von Knoten und ihren Merkmalen. Diese Darstellungen werden dann typischerweise in anderen ML-Systemen verwendet. Auf diese Weise können die diskreten, relationalen Informationen, die von einem Diagramm codiert werden, in typischere Anwendungsfälle neuronaler Netzwerke einbezogen werden. TF-GNN unterstützt eine feinkörnige Spezifikation unbeaufsichtigter Ziele für heterogene Graphen.

Aufbau von GNN-Architekturen

Die TF-GNN-Bibliothek unterstützt den Aufbau und das Coaching von GNNs auf verschiedenen Abstraktionsebenen.

Auf der höchsten Ebene können Benutzer jedes der vordefinierten Modelle verwenden, die in der Bibliothek enthalten sind und in Keras-Ebenen ausgedrückt werden. Neben einer kleinen Sammlung von Modellen aus der Forschungsliteratur verfügt TF-GNN über eine hochgradig konfigurierbare Modellvorlage, die eine kuratierte Auswahl an Modellierungsoptionen bietet, die unserer Erfahrung nach eine solide Grundlage für viele unserer internen Probleme bieten. Die Vorlagen implementieren GNN-Ebenen; Benutzer müssen lediglich die Keras-Ebenen initialisieren.

Auf der untersten Ebene können Benutzer ein GNN-Modell von Grund auf neu schreiben, und zwar in Type von Grundelementen zum Weiterleiten von Daten im Diagramm, z. B. das Senden von Daten von einem Knoten an alle ausgehenden Kanten oder das Zusammenfassen von Daten in einem Knoten von allen eingehenden Kanten (z. B. Berechnen der Summe der eingehenden Nachrichten). Das Diagrammdatenmodell von TF-GNN behandelt Knoten, Kanten und ganze Eingabediagramme gleich, wenn es um Options oder verborgene Zustände geht, wodurch es einfach ist, nicht nur knotenzentrierte Modelle wie das oben diskutierte MPNN auszudrücken, sondern auch allgemeinere Formen von GraphNets. Dies kann, muss aber nicht, mit Keras als Modellierungsframework auf dem Kern von TensorFlow erfolgen. Weitere Einzelheiten und Zwischenebenen der Modellierung finden Sie im TF-GNN Benutzerhandbuch Und Modellsammlung.

Trainingsorchestrierung

Während fortgeschrittene Benutzer die Möglichkeit haben, ein benutzerdefiniertes Modelltraining durchzuführen, ist die TF-GNN-Läufer Bietet außerdem eine prägnante Möglichkeit, das Coaching von Keras-Modellen in den häufigsten Fällen zu orchestrieren. Ein einfacher Aufruf könnte so aussehen:

The Runner bietet gebrauchsfertige Lösungen für ML-Probleme wie verteiltes Coaching und tfgnn.GraphTensor Polsterung für feste Formen auf Cloud-TPUs. Über das Coaching einer einzelnen Aufgabe hinaus (wie oben gezeigt) unterstützt es das gemeinsame Coaching mehrerer (zwei oder mehr) Aufgaben gleichzeitig. Beispielsweise können unbeaufsichtigte Aufgaben mit überwachten Aufgaben gemischt werden, um eine endgültige kontinuierliche Darstellung (oder Einbettung) mit anwendungsspezifischen induktiven Vorspannungen zu ermöglichen. Aufrufer müssen lediglich das Process-Argument durch eine Zuordnung von Duties ersetzen:

Darüber hinaus enthält der TF-GNN Runner auch eine Implementierung von integrierte Farbverläufe zur Verwendung bei der Modellzuordnung. Die integrierte Gradientenausgabe ist ein GraphTensor mit der gleichen Konnektivität wie der beobachtete GraphTensor, dessen Options jedoch durch Gradientenwerte ersetzt wurden, bei denen größere Werte mehr zur GNN-Vorhersage beitragen als kleinere Werte. Benutzer können Gradientenwerte überprüfen, um zu sehen, welche Options ihr GNN am häufigsten verwendet.

Abschluss

Kurz gesagt, wir hoffen, dass TF-GNN nützlich sein wird, um die Anwendung von GNNs in TensorFlow im großen Maßstab voranzutreiben und weitere Innovationen auf diesem Gebiet voranzutreiben. Wenn Sie neugierig sind und mehr erfahren möchten, probieren Sie bitte unsere aus Colab-Demo Durchsuchen Sie den Relaxation unseres Angebots mit dem beliebten OGBN-MAG-Benchmark (in Ihrem Browser, keine Set up erforderlich). Benutzerhandbücher und Colabsoder werfen Sie einen Blick auf unsere Papier.

Danksagungen

Die TF-GNN-Model 1.0 wurde in Zusammenarbeit mit Google Analysis entwickelt: Sami Abu-El-Haija, Neslihan Bulut, Bahar Fatemi, Johannes Gasteiger, Pedro Gonnet, Jonathan Halcrow, Liangze Jiang, Silvio Lattanzi, Brandon Mayer, Vahab Mirrokni, Bryan Perozzi, Anton Tsitsulin, Dustin Zelle, Google Core ML: Arno Eigenwillig, Oleksandr Ferludin, Parth Kothari, Mihir Paradkar, Jan Pfeifer, Rachael Tamakloe und Google DeepMind: Alvaro Sanchez-Gonzalez und Lisa Wang.